eyeprolog 1.5.8 → 1.5.10

package/README.md

@@ -61,7 +61,7 @@ Normal mode executes top-level `Conclusion :+ Premise` rules through the bundled
 
 Bundled `src/lib/` predicates autoload in files, CLI/API goals, and the REPL; use `--no-autoload` to require explicit imports, and explicitly import libraries that introduce operators before using their syntax. See [*The Art of EyeProlog*](the-art-of-eyeprolog.md) for the full semantics.
 
-The Trealla/Scryer compatibility surface now also includes chars-based term I/O and Base64 helpers, rational-form conversion in `library(arithmetic)`, `sleep/1`, the shared `library(iso_ext)` control/term re-exports, and focused `library(files)` and `library(os)` modules. Filesystem and OS side effects require Node; browser calls report an unavailable host resource instead. Non-integral `number_to_rational/2` results are represented structurally as `rdiv(Numerator,Denominator)` until rational numbers become processor numeric values.
+All 32 bundled modules that overlap Scryer's current `src/lib/` surface now cover Scryer's exported predicates, while the stricter Trealla/Scryer intersection remains a separate portability profile. Runtime-dependent library primitives follow one ownership rule: `src/lib/<module>.pl` calls private adapters from `src/<module>-host.js`; pure Prolog libraries need no host file. This includes the full Scryer `library(files)` surface, Scryer character-list paths in `library(pio)` with atom-path compatibility, chars/UTF-8/term/Base64 helpers, the completed arithmetic/time/`iso_ext` surfaces, and the full Scryer `library(crypto)`. Filesystem and OS side effects require Node; crypto uses Node's backend where needed, with Web Crypto also used for secure random bytes when available. Non-integral rational conversions remain structural `rdiv(Numerator,Denominator)` terms until rational numbers become processor numeric values.
 
 ## Links
 

package/package.json

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

package/src/ARCHITECTURE.md

@@ -15,8 +15,9 @@ higher-level frontends.
    `cleanup.js` owns lifecycle-aware disposal of protected builtin
    iterators and registers the normal-profile cleanup controls without making
    `solver.js` depend back on the language registry.
-4. **Language services** — `iso.js`, `iso-arithmetic.js`, `dcg.js`, `atts.js`,
-   `scryer-compat.js`, `library-host.js`, `standard-library.js`, and `src/lib/`.
+4. **Language services** — `iso.js`, `iso-arithmetic.js`, `dcg.js`, `atts-host.js`,
+   `standard-library.js`, the module-owned `src/<module>-host.js` adapters, and
+   the public Prolog modules under `src/lib/`.
 5. **Frontends/tools** — `execute.js`, `repl.js`, `cli.js`, `quads.js`,
    `explain.js`, and the playground worker.
 
@@ -40,7 +41,7 @@ annotations. Descriptors can optionally define logical subsumption so the
 store retains only its strongest pending constraints. `dif/2` is the first
 descriptor-based user of this mechanism.
 
-`atts.js` layers Prolog-visible attributed variables over that same persistent
+`atts-host.js` layers Prolog-visible attributed variables over that same persistent
 environment. Per-module attributes follow the current variable representative.
 When an attributed variable is about to be bound, the solver runs that module's
 `verify_attributes/3` against the still-unbound representative; only a successful
@@ -51,9 +52,9 @@ protocol directly for its domains and propagators.
 `Env` also owns the small generic backtrackable blackboard used by Scryer-style
 libraries. Blackboard maps are shared by clones and copied only on write, so
 `bb_b_put/2` follows ordinary Prolog backtracking without any CLP(Z)-specific
-state in the VM. `scryer-compat.js` exposes the private host bridge used by
-`library(debug)`; the remaining Scryer compatibility surface lives as Prolog
-modules under `src/lib/`.
+state in the VM. Its private runtime bridge is owned by `iso_ext-host.js`, matching
+Scryer's canonical `library(iso_ext)` ownership; `library(debug)` may re-export
+that interface for EyeProlog compatibility without owning another implementation.
 
 `source-expansion.js` is the explicit compile-time execution boundary. When an
 already-loaded `term_expansion/2` or `goal_expansion/2` hook exists, program
@@ -65,11 +66,17 @@ import graph acyclic while avoiding a second meta-interpreter solely for source
 expansion. `expansion-builtins.js` provides the lower-level `expand_term/2` DCG
 service without depending on `Solver`.
 
-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/`. Cleanup lifecycle hooks are
-installed from the public API and CLI entry paths; `standard-library.js` only
-registers the predicates, so the execution layer remains acyclic.
+The JavaScript runtime stays flat directly under `src/`; `src/lib/` contains the
+public Prolog library sources. Runtime-dependent library primitives follow a
+one-module/one-host convention: a private `eyeprolog__*` adapter referenced by
+`src/lib/foo.pl` must be registered from `src/foo-host.js`. Pure Prolog modules,
+such as `library(freeze)`, intentionally have no host file. `standard-library.js`
+registers these module hosts without owning their semantics. The architecture
+test rejects JavaScript import cycles, verifies private adapter ownership, freezes
+the current Scryer export surface for all 32 overlapping bundled modules, and
+rejects the retired `library-host.js` and `scryer-compat.js` grab bags. Cleanup
+lifecycle hooks are installed from the public API and CLI entry paths, so the
+execution layer remains acyclic.
 
 ## Performance rule
 

package/src/arithmetic-host.js

@@ -0,0 +1,116 @@
+// Runtime arithmetic conversions used by library(arithmetic).
+// Pure arithmetic relations stay in src/lib/arithmetic.pl.
+
+import { COMPOUND, NUMBER, VAR, compound, copyResolved, deref, numberTerm, unify } from './term.js';
+import { PrologError } from './errors.js';
+
+function gcdBigInt(a, b) {
+  a = a < 0n ? -a : a;
+  b = b < 0n ? -b : b;
+  while (b !== 0n) [a, b] = [b, a % b];
+  return a;
+}
+
+function approximateRational(value, tolerance = 1e-6) {
+  if (!Number.isFinite(value)) throw new PrologError('type_error(number)', numberTerm(String(value)));
+  if (!Number.isFinite(tolerance) || tolerance < 0) throw new PrologError('domain_error(not_less_than_zero)', numberTerm(String(tolerance)));
+  if (Number.isInteger(value) && Number.isSafeInteger(value)) return [BigInt(value), 1n];
+  const sign = value < 0 ? -1n : 1n;
+  const target = Math.abs(value);
+  let x = target;
+  let hPrev2 = 0, hPrev1 = 1, kPrev2 = 1, kPrev1 = 0;
+  for (let i = 0; i < 96; i++) {
+    const a = Math.floor(x);
+    const h = a * hPrev1 + hPrev2;
+    const k = a * kPrev1 + kPrev2;
+    if (!Number.isSafeInteger(h) || !Number.isSafeInteger(k) || k === 0) break;
+    if (Math.abs(target - h / k) <= tolerance) {
+      const n = sign * BigInt(h), d = BigInt(k), g = gcdBigInt(n, d);
+      return [n / g, d / g];
+    }
+    const fraction = x - a;
+    if (fraction === 0) {
+      const n = sign * BigInt(h), d = BigInt(k), g = gcdBigInt(n, d);
+      return [n / g, d / g];
+    }
+    [hPrev2, hPrev1] = [hPrev1, h];
+    [kPrev2, kPrev1] = [kPrev1, k];
+    x = 1 / fraction;
+  }
+
+  // Exact decimal-token fallback for continued fractions that exceed safe
+  // JavaScript integer intermediates.
+  const text = target.toString();
+  const match = /^(\d+)(?:\.(\d*))?(?:e([+-]?\d+))?$/i.exec(text);
+  if (!match) throw new PrologError('representation_error(rational)');
+  const fractionDigits = match[2] ?? '';
+  const exponent = Number(match[3] ?? 0);
+  let numerator = BigInt(match[1] + fractionDigits);
+  let denominator = 10n ** BigInt(fractionDigits.length);
+  if (exponent > 0) numerator *= 10n ** BigInt(exponent);
+  else if (exponent < 0) denominator *= 10n ** BigInt(-exponent);
+  numerator *= sign;
+  const g = gcdBigInt(numerator, denominator);
+  return [numerator / g, denominator / g];
+}
+
+function rationalParts(term, env, tolerance = 1e-6) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  if (value.type === NUMBER) {
+    if (/^-?\d+$/.test(value.name)) return [BigInt(value.name), 1n];
+    return approximateRational(Number(value.name), tolerance);
+  }
+  if (value.type === COMPOUND && value.name === 'rdiv' && value.arity === 2) {
+    const numerator = deref(value.args[0], env), denominator = deref(value.args[1], env);
+    if (numerator.type !== NUMBER || denominator.type !== NUMBER ||
+        !/^-?\d+$/.test(numerator.name) || !/^-?\d+$/.test(denominator.name)) {
+      throw new PrologError('type_error(rational)', copyResolved(value, env));
+    }
+    let n = BigInt(numerator.name), d = BigInt(denominator.name);
+    if (d === 0n) throw new PrologError('evaluation_error(zero_divisor)');
+    if (d < 0n) { n = -n; d = -d; }
+    const g = gcdBigInt(n, d);
+    return [n / g, d / g];
+  }
+  throw new PrologError('type_error(number)', copyResolved(value, env));
+}
+
+function rationalTerm(numerator, denominator) {
+  return denominator === 1n
+    ? numberTerm(numerator.toString())
+    : compound('rdiv', [numberTerm(numerator.toString()), numberTerm(denominator.toString())]);
+}
+
+function* numberToRationalBuiltin({ goal, env }) {
+  const [numerator, denominator] = rationalParts(goal.args[0], env);
+  const next = env.clone();
+  if (unify(goal.args[1], rationalTerm(numerator, denominator), next)) yield next;
+}
+
+function* numberToRationalToleranceBuiltin({ goal, env }) {
+  const epsilonTerm = deref(goal.args[0], env);
+  if (epsilonTerm.type === VAR) throw new PrologError('instantiation_error');
+  if (epsilonTerm.type !== NUMBER) throw new PrologError('type_error(number)', copyResolved(epsilonTerm, env));
+  const epsilon = Number(epsilonTerm.name);
+  if (!Number.isFinite(epsilon)) throw new PrologError('type_error(number)', copyResolved(epsilonTerm, env));
+  if (epsilon < 0) throw new PrologError('domain_error(not_less_than_zero)', copyResolved(epsilonTerm, env));
+  const [numerator, denominator] = rationalParts(goal.args[1], env, epsilon);
+  const next = env.clone();
+  if (unify(goal.args[2], rationalTerm(numerator, denominator), next)) yield next;
+}
+
+function* rationalPartsBuiltin({ goal, env }) {
+  const [numerator, denominator] = rationalParts(goal.args[0], env);
+  const next = env.clone();
+  if (unify(goal.args[1], numberTerm(numerator.toString()), next) &&
+      unify(goal.args[2], numberTerm(denominator.toString()), next)) yield next;
+}
+
+export const arithmeticHostBuiltins = {
+  register(registry) {
+    registry.add('eyeprolog__number_to_rational', 2, numberToRationalBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__number_to_rational', 3, numberToRationalToleranceBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__rational_numerator_denominator', 3, rationalPartsBuiltin, { deterministic: true, eyePrologLibrary: true });
+  },
+};

package/src/{atts.js → atts-host.js}

@@ -11,6 +11,7 @@ import {
   properListItems, unify, variable,
 } from './term.js';
 import { PrologError } from './errors.js';
+import { callResidueVarsBuiltin } from './iso.js';
 
 function callerModule(goal) {
   return goal.module ?? 'user';
@@ -217,8 +218,9 @@ function* delFromAttrListBuiltin({ goal, env }) {
   yield next;
 }
 
-export const attsBuiltins = {
+export const attsHostBuiltins = {
   register(registry) {
+    registry.add('eyeprolog__call_residue_vars', 2, callResidueVarsBuiltin, { eyePrologLibrary: true });
     registry.add('put_atts', 2, putAttsBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('get_atts', 2, getAttsBuiltin, { deterministic: true, eyePrologLibrary: true });
     // Scryer's CLP(Z) sources use these through goal expansion. EyeProlog

package/src/charsio-host.js

@@ -0,0 +1,380 @@
+// Runtime character parsing/writing and character classification for
+// library(charsio). Portable UTF-8 relations remain in src/lib/charsio.pl.
+
+import { createParserOperatorState, parseTermText } from './parser.js';
+import { BufferCtor } from './platform.js';
+import {
+  ATOM, COMPOUND, NUMBER, VAR, atom, compound, copyResolved, deref,
+  listFromItems, numberTerm, properListItems, unify, variable,
+} from './term.js';
+import { PrologError } from './errors.js';
+import { formatTermForWrite } from './write.js';
+import { characterListText, chars } from './host-utils.js';
+
+let readFresh = 0;
+function activeCharConverter(solver) {
+  if (solver.prologFlags.get('char_conversion')?.value?.name !== 'on' || solver.charConversions.size === 0) {
+    return null;
+  }
+  return (character) => solver.charConversions.get(character) ?? character;
+}
+
+function convertTextCharacters(text, solver) {
+  const convert = activeCharConverter(solver);
+  if (convert == null) return text;
+  let result = '', quote = null;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i], next = text[i + 1];
+    if (quote != null) {
+      result += ch;
+      if (ch === '\\') {
+        if (i + 1 < text.length) result += text[++i];
+      } else if (ch === quote && next === quote) {
+        result += text[++i];
+      } else if (ch === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      result += ch;
+    } else {
+      result += convert(ch);
+    }
+  }
+  return result;
+}
+
+function scopeReadTerm(term) {
+  const scope = ++readFresh;
+  const bySourceName = new Map();
+  const variables = [];
+  const copy = (item) => {
+    if (item.type === VAR) {
+      let record = bySourceName.get(item.name);
+      if (record == null) {
+        const scoped = variable(`\u0000chars:${scope}:${variables.length}`);
+        scoped.displayName = item.name;
+        record = {
+          sourceName: item.name,
+          term: scoped,
+          count: 0,
+          anonymous: item.name.startsWith('__anon'),
+        };
+        bySourceName.set(item.name, record);
+        variables.push(record);
+      }
+      record.count++;
+      return record.term;
+    }
+    if (item.type !== COMPOUND) return item;
+    return compound(item.name, item.args.map(copy));
+  };
+  return { term: copy(term), variables };
+}
+
+function readTextTerm(text, solver) {
+  const converted = convertTextCharacters(text, solver);
+  try {
+    const operatorState = createParserOperatorState(solver.program.operators.values(), false);
+    const parsed = parseTermText(converted, {
+      operatorState,
+      isoStrict: solver.isoStrict,
+      doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+      readTermEnd: converted.endsWith('.') ? converted.length - 1 : undefined,
+    });
+    return scopeReadTerm(parsed);
+  } catch (error) {
+    if (error instanceof PrologError) throw error;
+    throw new PrologError('syntax_error(read_term)');
+  }
+}
+
+function requireOptionList(term, env, kind) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  const options = properListItems(value, env);
+  if (options == null) throw new PrologError('type_error(list)', copyResolved(value, env));
+  for (const optionTerm of options) {
+    if (deref(optionTerm, env).type === VAR) throw new PrologError('instantiation_error');
+  }
+  return options.map((option) => deref(option, env));
+}
+
+function* readFromCharsBuiltin({ solver, goal, env }) {
+  const text = characterListText(goal.args[0], env);
+  const { term } = readTextTerm(text, solver);
+  const next = env.clone();
+  if (unify(goal.args[1], term, next)) yield next;
+}
+
+function* readTermFromCharsBuiltin({ solver, goal, env }) {
+  const text = characterListText(goal.args[0], env);
+  const options = requireOptionList(goal.args[2], env, 'read');
+  for (const option of options) {
+    if (option.type !== COMPOUND || option.arity !== 1 ||
+        !['variables', 'variable_names', 'singletons'].includes(option.name)) {
+      throw new PrologError('domain_error(read_option)', copyResolved(option, env));
+    }
+  }
+  const { term, variables } = readTextTerm(text, solver);
+  const next = env.clone();
+  if (!unify(goal.args[1], term, next)) return;
+  for (const option of options) {
+    const value = option.name === 'variables'
+      ? listFromItems(variables.map((item) => item.term))
+      : option.name === 'variable_names'
+        ? listFromItems(variables
+          .filter((item) => !item.anonymous)
+          .map((item) => compound('=', [atom(item.sourceName), item.term])))
+        : listFromItems(variables
+          .filter((item) => !item.anonymous && item.count === 1)
+          .map((item) => compound('=', [atom(item.sourceName), item.term])));
+    if (!unify(option.args[0], value, next)) return;
+  }
+  yield next;
+}
+
+function optionBoolean(term, env, option) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  if (value.type !== ATOM || !['true', 'false'].includes(value.name)) {
+    throw new PrologError('domain_error(write_option)', copyResolved(option, env));
+  }
+  return value.name === 'true';
+}
+
+function variableNamesOption(term, env, option) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  const items = properListItems(value, env);
+  if (items == null) throw new PrologError('domain_error(write_option)', copyResolved(option, env));
+  const names = new Map();
+  for (const itemTerm of items) {
+    const item = deref(itemTerm, env);
+    if (item.type !== COMPOUND || item.name !== '=' || item.arity !== 2) {
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
+    }
+    const name = deref(item.args[0], env);
+    const target = deref(item.args[1], env);
+    if (name.type === VAR) throw new PrologError('instantiation_error');
+    if (name.type !== ATOM) throw new PrologError('domain_error(write_option)', copyResolved(option, env));
+    if (target.type === VAR && !names.has(target.name)) names.set(target.name, name.name);
+  }
+  return names;
+}
+
+function writeOptions(term, env, solver) {
+  const options = requireOptionList(term, env, 'write');
+  const result = {
+    quoted: false,
+    ignoreOps: false,
+    numbervars: false,
+    variableNames: new Map(),
+    compact: true,
+    minimalOperatorSpacing: true,
+    operatorAtomsAsArgs: true,
+    doubleQuotes: null,
+  };
+  for (const option of options) {
+    if (option.type !== COMPOUND || option.arity !== 1) {
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
+    }
+    if (option.name === 'quoted') result.quoted = optionBoolean(option.args[0], env, option);
+    else if (option.name === 'ignore_ops') result.ignoreOps = optionBoolean(option.args[0], env, option);
+    else if (option.name === 'numbervars') result.numbervars = optionBoolean(option.args[0], env, option);
+    else if (option.name === 'variable_names') result.variableNames = variableNamesOption(option.args[0], env, option);
+    else if (option.name === 'double_quotes' && !solver.isoStrict) result.doubleQuotes = optionBoolean(option.args[0], env, option);
+    else throw new PrologError('domain_error(write_option)', copyResolved(option, env));
+  }
+  return result;
+}
+
+function* writeTermToCharsBuiltin({ solver, goal, env }) {
+  if (deref(goal.args[2], env).type !== VAR) {
+    throw new PrologError('uninstantiation_error', copyResolved(goal.args[2], env));
+  }
+  const options = writeOptions(goal.args[1], env, solver);
+  const text = formatTermForWrite(goal.args[0], env, {
+    ...options,
+    generateVariableNames: true,
+    variableNameState: solver.writeVariableState,
+    operators: solver.program.operators.values(),
+  });
+  const next = env.clone();
+  if (unify(goal.args[2], chars(text), next)) yield next;
+}
+
+function base64Options(term, env) {
+  const options = requireOptionList(term, env, 'base64');
+  let padding = true, charset = 'standard';
+  for (const option of options) {
+    if (option.type !== COMPOUND || option.arity !== 1) {
+      throw new PrologError('domain_error(base64_option)', copyResolved(option, env));
+    }
+    const value = deref(option.args[0], env);
+    if (value.type === VAR) throw new PrologError('instantiation_error');
+    if (option.name === 'padding') {
+      if (value.type !== ATOM || !['true', 'false'].includes(value.name)) {
+        throw new PrologError('domain_error(boolean)', copyResolved(value, env));
+      }
+      padding = value.name === 'true';
+    } else if (option.name === 'charset') {
+      if (value.type !== ATOM || !['standard', 'url'].includes(value.name)) {
+        throw new PrologError('domain_error(charset)', copyResolved(value, env));
+      }
+      charset = value.name;
+    } else {
+      throw new PrologError('domain_error(base64_option)', copyResolved(option, env));
+    }
+  }
+  return { padding, charset };
+}
+
+function base64Encode(text, charset, padding) {
+  const bytes = [];
+  for (const ch of Array.from(text)) {
+    const code = ch.codePointAt(0);
+    if (code > 255) throw new PrologError('domain_error(octet_character)', numberTerm(code));
+    bytes.push(code);
+  }
+  let encoded;
+  if (BufferCtor != null) encoded = BufferCtor.from(bytes).toString('base64');
+  else if (typeof btoa === 'function') encoded = btoa(String.fromCharCode(...bytes));
+  else throw new PrologError('resource_error(base64)');
+  if (charset === 'url') encoded = encoded.replace(/\+/g, '-').replace(/\//g, '_');
+  if (!padding) encoded = encoded.replace(/=+$/, '');
+  return encoded;
+}
+
+function base64Decode(text, charset) {
+  let encoded = text;
+  if (charset === 'url') encoded = encoded.replace(/-/g, '+').replace(/_/g, '/');
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 === 1) {
+    throw new PrologError('domain_error(base64)', chars(text));
+  }
+  encoded += '='.repeat((4 - encoded.length % 4) % 4);
+  let bytes;
+  if (BufferCtor != null) bytes = [...BufferCtor.from(encoded, 'base64')];
+  else if (typeof atob === 'function') bytes = [...atob(encoded)].map((ch) => ch.charCodeAt(0));
+  else throw new PrologError('resource_error(base64)');
+  return String.fromCharCode(...bytes);
+}
+
+function* charsBase64Builtin({ goal, env }) {
+  const source = deref(goal.args[0], env);
+  const encoded = deref(goal.args[1], env);
+  if (source.type === VAR && encoded.type === VAR) throw new PrologError('instantiation_error');
+  const { padding, charset } = base64Options(goal.args[2], env);
+  const next = env.clone();
+  if (source.type !== VAR) {
+    const text = characterListText(goal.args[0], env);
+    if (unify(goal.args[1], chars(base64Encode(text, charset, padding)), next)) yield next;
+    return;
+  }
+  const text = characterListText(goal.args[1], env);
+  if (unify(goal.args[0], chars(base64Decode(text, charset)), next)) yield next;
+}
+
+function charTypeCandidates(ch) {
+  const code = ch.codePointAt(0);
+  const letter = /\p{L}/u.test(ch);
+  const decimal = /\p{Nd}/u.test(ch);
+  const numeric = /\p{N}/u.test(ch);
+  const whitespace = /\s/u.test(ch);
+  const control = /\p{Cc}/u.test(ch);
+  const lower = /\p{Ll}/u.test(ch);
+  const upper = /\p{Lu}/u.test(ch);
+  const asciiGraphic = code >= 0x21 && code <= 0x7e;
+  const out = [];
+  const add = (name, yes) => { if (yes) out.push(atom(name)); };
+  add('alnum', letter || decimal);
+  add('alpha', letter);
+  add('alphabetic', letter);
+  add('alphanumeric', letter || decimal);
+  add('ascii', code <= 0x7f);
+  add('ascii_graphic', asciiGraphic);
+  add('ascii_punctuation', asciiGraphic && !letter && !decimal);
+  add('binary_digit', ch === '0' || ch === '1');
+  add('control', control);
+  add('decimal_digit', decimal);
+  add('exponent', ch === 'e' || ch === 'E');
+  add('graphic', !whitespace && !control);
+  add('graphic_token', '#$&*+-./:<=>?@\\^~'.includes(ch));
+  add('hexadecimal_digit', /^[0-9A-Fa-f]$/.test(ch));
+  add('layout', whitespace);
+  add('lower', lower);
+  add('meta', "\\'\"`".includes(ch));
+  add('numeric', numeric);
+  add('octal_digit', /^[0-7]$/.test(ch));
+  add('octet', code <= 0xff);
+  add('prolog', true);
+  add('sign', ch === '+' || ch === '-');
+  add('solo', '!,;[]{}()|'.includes(ch));
+  add('symbolic_control', '#$&*+-./:<=>?@\\^~'.includes(ch));
+  add('symbolic_hexadecimal', /^[A-Fa-f]$/.test(ch));
+  add('upper', upper);
+  add('whitespace', whitespace);
+  out.push(compound('lower', [listFromItems([...ch.toLowerCase()].map(atom))]));
+  out.push(compound('upper', [listFromItems([...ch.toUpperCase()].map(atom))]));
+  return out;
+}
+
+function validCharType(term) {
+  return (term.type === ATOM && charTypeNames.has(term.name)) ||
+    (term.type === COMPOUND && ['lower', 'upper'].includes(term.name) && term.arity === 1);
+}
+
+function charTypeBuiltin(context) {
+  const state = { pending: false };
+  const iterator = charTypeSolutions(context, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
+}
+
+function* charTypeSolutions({ goal, env }, state) {
+  const char = deref(goal.args[0], env);
+  const type = deref(goal.args[1], env);
+  if (char.type === VAR && type.type === VAR) throw new PrologError('instantiation_error');
+  if (char.type !== VAR && (char.type !== ATOM || [...char.name].length !== 1)) {
+    throw new PrologError('type_error(character)', char);
+  }
+  if (type.type !== VAR && !validCharType(type)) throw new PrologError('domain_error(char_type)', type);
+
+  const firstCode = char.type === VAR ? 0 : char.name.codePointAt(0);
+  const lastCode = char.type === VAR ? 0x10ffff : firstCode;
+  for (let code = firstCode; code <= lastCode; code++) {
+    if (code >= 0xd800 && code <= 0xdfff) continue;
+    const ch = String.fromCodePoint(code);
+    const candidates = charTypeCandidates(ch).filter((candidate) =>
+      type.type === VAR || (candidate.type === type.type && candidate.name === type.name));
+    for (let index = 0; index < candidates.length; index++) {
+      const candidate = candidates[index];
+      const next = env.clone();
+      if (unify(goal.args[0], atom(ch), next) && unify(goal.args[1], candidate, next)) {
+        state.pending = index + 1 < candidates.length || code < lastCode;
+        yield next;
+      }
+    }
+  }
+  state.pending = false;
+}
+
+const shortMonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const longMonths = ['January', 'February', 'March', 'April', 'May', 'June',
+  'July', 'August', 'September', 'October', 'November', 'December'];
+const shortWeekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const longWeekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+
+export const charsioHostBuiltins = {
+  register(registry) {
+    registry.add('eyeprolog__char_type', 2, charTypeBuiltin, { eyePrologLibrary: true });
+    registry.add('eyeprolog__read_from_chars', 2, readFromCharsBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__read_term_from_chars', 3, readTermFromCharsBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__write_term_to_chars', 3, writeTermToCharsBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__chars_base64', 3, charsBase64Builtin, { deterministic: true, eyePrologLibrary: true });
+  },
+};