eyeprolog 1.5.35 → 1.5.37

package/README.md

@@ -86,7 +86,7 @@ The checked [Symbiotic Knowledge Graphs example](examples/symbiotic-knowledge-gr
 The same RDF → Prolog → RDF boundary is exercised by five additional checked scenarios: [cross-organization data sharing](https://eyereasoner.github.io/eyeprolog/examples/deck/cross-organization-data-sharing), [explainable EV-depot configuration](https://eyereasoner.github.io/eyeprolog/examples/deck/explainable-ev-depot-configuration), [operational incident response](https://eyereasoner.github.io/eyeprolog/examples/deck/operational-incident-response), [software supply-chain vulnerability response](https://eyereasoner.github.io/eyeprolog/examples/deck/sbom-vulnerability-response), and a [scientific evidence graph](https://eyereasoner.github.io/eyeprolog/examples/deck/scientific-evidence-graph). Together they cover policy decisions, reversible configuration reasoning, dependency-graph diagnosis, transitive SBOM exposure, and evidence aggregation with explicit disagreement.
 
 ## Benchmarks
-EyeProlog has 21 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, and the classic Prolog naive-reverse workload. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark:baseline`; use `npm run test:benchmark` for harness checks. The checked [`examples/bench.pl`](examples/bench.pl) preserves the classic Quintus 1984 `nrev/2` workload on a 30-element list. For a comparable LIPS number, run `npm run benchmark:lips`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog, subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. The generic benchmark table still shows a quick wall-clock LIPS estimate for `classic-nrev`, but `benchmark:lips` is the canonical engine-speed measurement. LIPS is a historical basic-engine-speed indicator, not a whole-system performance score. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
+EyeProlog has 19 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, and the classic Prolog naive-reverse workload. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark:baseline`; use `npm run test:benchmark` for harness checks. The checked [`examples/bench.pl`](examples/bench.pl) preserves the classic Quintus 1984 `nrev/2` workload on a 30-element list. For a comparable LIPS number, run `npm run benchmark:lips`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog, subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. The generic benchmark table still shows a quick wall-clock LIPS estimate for `classic-nrev`, but `benchmark:lips` is the canonical engine-speed measurement. LIPS is a historical basic-engine-speed indicator, not a whole-system performance score. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
 For the project policy on post-ISO-standard and WG17 compatibility features such as digit separators, see [ISO/WG17 compatibility extensions](test/conformance/ISO-WG17-EXTENSIONS.md).
 ## Development
 ```sh

package/examples/bulk-stream-write.pl

@@ -0,0 +1,42 @@
+% Bulk character-by-character writes to a non-console text stream.
+%
+% put_char/2 writes one character at a time to an open file stream, and each
+% write logically appends at the current stream position (ISO 7.10.2.8). This
+% is the common pattern for hand-rolled serializers that emit one character or
+% code point per call rather than a single bulk write/1 call. The example
+% writes a repeating a-z run to a temporary file, closes it, then reopens and
+% reads the file back one character at a time with get_char/2 to confirm every
+% character round-trips. The path is under /tmp so the source tree is
+% unchanged.
+
+%% goal: bulk_write_result(X0, X1)
+
+bulk_write_chars(_, 0) :- !.
+bulk_write_chars(Stream, N) :-
+  N > 0,
+  Code is 0'a + (N mod 26),
+  char_code(Char, Code),
+  put_char(Stream, Char),
+  N1 is N - 1,
+  bulk_write_chars(Stream, N1).
+
+count_chars(Stream, Acc, Count) :-
+  get_char(Stream, Char),
+  count_chars_step(Char, Stream, Acc, Count).
+
+count_chars_step(end_of_file, _, Count, Count) :- !.
+count_chars_step(_, Stream, Acc, Count) :-
+  Acc1 is Acc + 1,
+  count_chars(Stream, Acc1, Count).
+
+bulk_write_path('/tmp/eyeprolog-bulk-stream-write-example.txt').
+
+bulk_write_result(Requested, Counted) :-
+  Requested = 5000,
+  bulk_write_path(Path),
+  open(Path, write, Out, [type(text)]),
+  bulk_write_chars(Out, Requested),
+  close(Out),
+  open(Path, read, In, [type(text)]),
+  count_chars(In, 0, Counted),
+  close(In).

package/examples/output/bulk-stream-write.pl

@@ -0,0 +1 @@
+bulk_write_result(5000, 5000).

package/package.json

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

package/playground.html

@@ -459,6 +459,7 @@
           "bmi",
           "braking-safety-worlds",
           "buck-converter-design",
+          "bulk-stream-write",
           "cache-performance",
           "canary-release",
           "cat-koko",

package/src/explain.js

@@ -218,7 +218,12 @@ function builtinIsUsedForGoal(def, solver, goal, env) {
 function selectReadyDeterministicBuiltin(goals, env, registry) {
   for (let i = 0; i < goals.length; i++) {
     const goal = goals[i];
-    if (goal.type !== COMPOUND) continue;
+    // Match solver.js's goal-type check: a 0-arity builtin (ATOM) is just as
+    // eligible for this fast path as a COMPOUND one. No bundled builtin
+    // currently pairs arity 0 with a custom ready() gate, so this has no
+    // observable effect today, but it keeps the proof-explanation path from
+    // silently diverging from actual execution if one is added later.
+    if (goal.type !== COMPOUND && goal.type !== ATOM) continue;
     const def = registry.get(goal.name, goal.arity);
     if (!def?.deterministic || typeof def.ready !== 'function') continue;
     if (typeof def.shouldUse === 'function') continue;

package/src/io.js

@@ -186,6 +186,21 @@ export class StreamManager {
     }
     const text = String(value);
     const content = String(stream.content);
+    // The overwhelming majority of text-stream writes append at the current
+    // end of the sink: bulk write/1 calls and repeated put_char/put_code
+    // loops alike. Handling that case as a plain concatenation, separate
+    // from the general reposition rebuild below, keeps the two ISO-distinct
+    // cases self-documenting instead of folding them into one three-part
+    // slice expression that always pays for the overwrite case's shape.
+    // This split is for clarity, not raw throughput: measured end to end,
+    // the general expression already performs comparably for this pattern.
+    if (stream.position === content.length) {
+      stream.content = content + text;
+      stream.position += text.length;
+      return;
+    }
+    // 7.10.2.8: output after repositioning overwrites the existing sink
+    // contents at the selected stream position rather than always appending.
     const end = Math.min(content.length, stream.position + text.length);
     stream.content = `${content.slice(0, stream.position)}${text}${content.slice(end)}`;
     stream.position += text.length;

package/src/parser.js

@@ -238,6 +238,12 @@ export function createParserOperatorState(definitions = [], includeDefaults = tr
   }
   return state;
 }
+// Pre-compiled character-class regexes used in the lexer hot path.
+const RE_OCTAL_DIGIT = /^[0-7]$/;
+const RE_HEX_DIGIT = /^[0-9A-Fa-f]$/;
+const RE_DECIMAL_DIGIT = /^[0-9]$/;
+const RE_BINARY_DIGIT = /^[01]$/;
+
 
 class Parser {
   constructor(source, options = {}) {
@@ -480,7 +486,7 @@ class Parser {
 
     if (escaped === 'x') {
       let digits = '';
-      while (/^[0-9A-Fa-f]$/.test(peekChar())) digits += takeChar();
+      while (RE_HEX_DIGIT.test(peekChar())) digits += takeChar();
       if (!digits || takeChar() !== '\\') throw new Error(`parse line ${line}: bad hexadecimal escape`);
       const code = Number.parseInt(digits, 16);
       if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
@@ -489,9 +495,9 @@ class Parser {
       if (this.strictIso && !isStrictIsoPcsCodePoint(code)) throw new CharacterRepresentationError();
       return String.fromCodePoint(code);
     }
-    if (/^[0-7]$/.test(escaped)) {
+    if (RE_OCTAL_DIGIT.test(escaped)) {
       let digits = escaped;
-      while (/^[0-7]$/.test(peekChar())) digits += takeChar();
+      while (RE_OCTAL_DIGIT.test(peekChar())) digits += takeChar();
       if (takeChar() !== '\\') throw new Error(`parse line ${line}: bad octal escape`);
       const code = Number.parseInt(digits, 8);
       if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
@@ -503,7 +509,7 @@ class Parser {
     // A backslash followed by a decimal digit is numeric-escape syntax, but
     // ISO octal digits are limited to 0..7.  Do not reinterpret \8 or \9 as
     // implementation-specific one-character escapes.
-    if (/^[0-9]$/.test(escaped)) throw new Error(`parse line ${line}: bad octal escape`);
+    if (RE_DECIMAL_DIGIT.test(escaped)) throw new Error(`parse line ${line}: bad octal escape`);
 
     // The only remaining ISO meta escapes are the four meta characters from
     // 6.5.5.  Forms such as \c, \d, \e, \u or \. are not quoted
@@ -652,9 +658,9 @@ class Parser {
         return { type: TOK.NUMBER, text: String(negative ? -code : code), line };
       }
       const radixKind = this.peek() === '0' ? this.peek(1) : '';
-      const radixHasDigit = radixKind === 'b' ? /^[01]$/.test(this.peek(2))
-        : radixKind === 'o' ? /^[0-7]$/.test(this.peek(2))
-        : radixKind === 'x' ? /^[0-9A-Fa-f]$/.test(this.peek(2))
+      const radixHasDigit = radixKind === 'b' ? RE_BINARY_DIGIT.test(this.peek(2))
+        : radixKind === 'o' ? RE_OCTAL_DIGIT.test(this.peek(2))
+        : radixKind === 'x' ? RE_HEX_DIGIT.test(this.peek(2))
         : false;
       if (radixHasDigit) {
         this.take();
@@ -1816,14 +1822,14 @@ export function parseNumberTokenText(text, options = {}) {
         value = controls[escaped];
       } else if (escaped === 'x') {
         let digits = '';
-        while (/^[0-9A-Fa-f]$/.test(source[position] ?? '')) digits += source[position++];
+        while (RE_HEX_DIGIT.test(source[position] ?? '')) digits += source[position++];
         if (!digits || source[position++] !== '\\') throw invalidNumberTokenError;
         const code = Number.parseInt(digits, 16);
         if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) throw invalidNumberTokenError;
         value = String.fromCodePoint(code);
-      } else if (/^[0-7]$/.test(escaped)) {
+      } else if (RE_OCTAL_DIGIT.test(escaped)) {
         let digits = escaped;
-        while (/^[0-7]$/.test(source[position] ?? '')) digits += source[position++];
+        while (RE_OCTAL_DIGIT.test(source[position] ?? '')) digits += source[position++];
         if (source[position++] !== '\\') throw invalidNumberTokenError;
         const code = Number.parseInt(digits, 8);
         if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) throw invalidNumberTokenError;

package/src/program-analysis.js

@@ -65,7 +65,9 @@ function reachableIndexesTransposed(target, deps, candidates) {
   const reverse = new Map();
   for (const from of candidates) {
     if (!reverse.has(from)) reverse.set(from, []);
-    for (const to of deps[from]) {
+    const edges = deps[from];
+    if (edges == null) continue;
+    for (const to of edges) {
       if (!candidates.has(to)) continue;
       let bucket = reverse.get(to);
       if (bucket == null) { bucket = []; reverse.set(to, bucket); }

package/src/program.js

@@ -29,9 +29,12 @@ import {
 } from './program-indexing.js';
 export { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
 import {
+
   componentHasNegativeEdge, componentHasCut, reachableIndexes, datalogDependencyClauseCount, isFiniteDatalogGroup, isRangeRestrictedFiniteDatalogGroup, isFiniteWfsDatalogGroup, inferStructuralInputPositions, hasStrictListTailRecursion, hasLinearNumericRecursion, isPiAccumulator, isPortableBetweenGenerator, directGoalDependencyKey, collectGoalDependencies, stronglyConnectedComponents, computeNegationStrata,
 } from './program-analysis.js';
 
+const RE_DECIMAL_INT = /^\d+$/;
+
 const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
 const FAST_PARSE_ABORT = Symbol('fastParseAbort');
 const PROGRAM_BUILD_BATCH_SIZE = 16384;
@@ -303,7 +306,7 @@ export class Program {
     const positions = [];
     for (let index = 0; index < template.args.length; index++) {
       const spec = template.args[index];
-      if ((spec.type === 'number' && /^\d+$/.test(spec.name)) ||
+      if ((spec.type === 'number' && RE_DECIMAL_INT.test(spec.name)) ||
           (spec.type === ATOM && spec.name === ':')) positions.push(index);
     }
     const definitions = this.moduleMetaPredicates.get(module) ?? new Map();
@@ -1653,7 +1656,7 @@ function moduleExportIndicators(term) {
     if (item.type === COMPOUND && item.name === 'op' && item.arity === 3) {
       const [priority, specifier, names] = item.args;
       const operatorNames = names.type === ATOM ? [names] : properListItems(names, new Env());
-      if (priority.type !== NUMBER || !/^\d+$/.test(priority.name) || Number(priority.name) > 1200 ||
+      if (priority.type !== NUMBER || !RE_DECIMAL_INT.test(priority.name) || Number(priority.name) > 1200 ||
           specifier.type !== ATOM || !['fx', 'fy', 'xf', 'yf', 'xfx', 'xfy', 'yfx'].includes(specifier.name) ||
           operatorNames == null || operatorNames.some((name) => name.type !== ATOM)) return null;
       continue;
@@ -1832,7 +1835,7 @@ function staticProcedureModificationError(name, arity) {
 
 function predicateIndicator(name, arity) {
   if (name?.type !== ATOM || arity?.type !== 'number') return null;
-  if (!/^\d+$/.test(arity.name)) return null;
+  if (!RE_DECIMAL_INT.test(arity.name)) return null;
   const arityNumber = Number(arity.name);
   return { name: name.name, arity: arityNumber, key: `${name.name}/${arityNumber}` };
 }

package/src/term.js

@@ -72,7 +72,7 @@ export class CompactListTerm {
   mayContainVariable(name, env = null) {
     if (String(name).startsWith(this._variablePrefix)) {
       const indexText = String(name).slice(this._variablePrefix.length);
-      if (/^\d+$/.test(indexText)) {
+      if (RE_DIGIT_STR.test(indexText)) {
         const index = BigInt(indexText);
         if (index >= this._offset && index < this._offset + this._compactLength) return true;
       }
@@ -1268,17 +1268,22 @@ export function copyResolved(term, env) {
 }
 
 export function termIsGround(term, env = new Env()) {
+  // Defer the cycle-guard Set until we encounter a compound term, since
+  // the overwhelming majority of ground checks are on acyclic clause data.
   const pending = [term];
-  const seen = new Set();
+  let seen = null;
   while (pending.length > 0) {
     const resolved = deref(pending.pop(), env);
     if (resolved.type === VAR) return false;
+    const arity = resolved.args.length;
+    if (arity === 0) continue;
+    if (seen == null) seen = new Set();
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     // Visit leftmost arguments first. Lists and other recursive structures
     // commonly carry their first unbound variable there, allowing a
     // non-ground check to finish without walking the complete tail.
-    for (let index = resolved.args.length - 1; index >= 0; index--) {
+    for (let index = arity - 1; index >= 0; index--) {
       pending.push(resolved.args[index]);
     }
   }
@@ -1287,11 +1292,18 @@ export function termIsGround(term, env = new Env()) {
 
 const graphicAtomChars = new Set('!#$&*+-/<=>@^~\\'.split(''));
 
+const RE_LOWER_IDENT = /^[a-z][A-Za-z0-9_]*$/;
+const RE_UPPER_IDENT = /^(?:_|[A-Z_][A-Za-z0-9_]*)$/;
+const RE_LEGACY_VAR = /^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/;
+const RE_FLOAT = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+const RE_DIGIT_STR = /^\d+$/;
+const RE_SANITIZE_VAR = /[^A-Za-z0-9_]/g;
+const RE_UPPER_START = /^[A-Z_]/;
 function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]' || name === '{}') return false;
   if (name === '\\+' || name === '+' || name === '-' || name === '\\') return true;
-  if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return false;
+  if (RE_LOWER_IDENT.test(name)) return false;
   for (const ch of name) if (!graphicAtomChars.has(ch)) return true;
   return false;
 }
@@ -1322,11 +1334,11 @@ function legacyVariableToIso(name) {
 
 function writeVariable(name) {
   name = String(name ?? '');
-  if (/^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/.test(name)) return legacyVariableToIso(name);
-  if (/^(?:_|[A-Z_][A-Za-z0-9_]*)$/.test(name)) return name;
-  const sanitized = name.replace(/[^A-Za-z0-9_]/g, '_');
+  if (RE_LEGACY_VAR.test(name)) return legacyVariableToIso(name);
+  if (RE_UPPER_IDENT.test(name)) return name;
+  const sanitized = name.replace(RE_SANITIZE_VAR, '_');
   if (!sanitized) return '_';
-  return /^[A-Z_]/.test(sanitized) ? sanitized : `_${sanitized}`;
+  return RE_UPPER_START.test(sanitized) ? sanitized : `_${sanitized}`;
 }
 
 function writeString(value, quoteStrings) {
@@ -1363,7 +1375,7 @@ function quotedListSplice(term, env, doubleQuotes) {
       if (item.type !== ATOM || Array.from(item.name).length !== 1) return null;
       characters.push(item.name);
     } else {
-      if (item.type !== NUMBER || !/^\d+$/.test(item.name)) return null;
+      if (item.type !== NUMBER || !RE_DIGIT_STR.test(item.name)) return null;
       const code = BigInt(item.name);
       if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) return null;
       characters.push(String.fromCodePoint(Number(code)));
@@ -1558,12 +1570,16 @@ function variableRank(name, ranks) {
   return rank;
 }
 
+// ISO standard order: variables < numbers < atoms < strings < compound.
+// Defined once to avoid allocating a fresh object literal on every comparison.
+const TYPE_ORDER = { [VAR]: 0, [NUMBER]: 1, [ATOM]: 2, [STRING]: 3, [COMPOUND]: 4 };
+const EMPTY_ENV = new Env();
+
 function compareTermsWithRanks(left, right, variableRanks) {
-  const rank = (term) => ({ [VAR]: 0, [NUMBER]: 1, [ATOM]: 2, [STRING]: 3, [COMPOUND]: 4 })[term.type];
-  left = deref(left, new Env());
-  right = deref(right, new Env());
-  const lr = rank(left);
-  const rr = rank(right);
+  left = deref(left, EMPTY_ENV);
+  right = deref(right, EMPTY_ENV);
+  const lr = TYPE_ORDER[left.type] ?? 0;
+  const rr = TYPE_ORDER[right.type] ?? 0;
   if (lr !== rr) return lr < rr ? -1 : 1;
   if (left.type === NUMBER) {
     const leftInteger = isDecimalInteger(left.name);
@@ -1587,8 +1603,9 @@ function compareTermsWithRanks(left, right, variableRanks) {
   return 0;
 }
 
+const RE_DECIMAL_INTEGER = /^-?\d+$/;
 export function isDecimalInteger(text) {
-  return /^-?\d+$/.test(text ?? '');
+  return RE_DECIMAL_INTEGER.test(text ?? '');
 }
 
 export function compareIntegerText(left, right) {
@@ -1599,7 +1616,7 @@ export function compareIntegerText(left, right) {
 
 export function parseFiniteNumber(text) {
   if (text == null || text === '') return null;
-  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(text)) return null;
+  if (!RE_FLOAT.test(text)) return null;
   const n = Number(text);
   return Number.isFinite(n) ? n : null;
 }

package/src/wfs.js

@@ -21,9 +21,15 @@ import {
   resolvePatternTerm,
 } from './datalog-common.js';
 
+const _wfsScalarKeyCache = new WeakMap();
 function scalarKey(term) {
-  if (term.type === 'number') return `number\u0000${numberValueKey(term.name)}`;
-  return `${term.type}\u0000${term.name}`;
+  const cached = _wfsScalarKeyCache.get(term);
+  if (cached != null) return cached;
+  const key = term.type === 'number'
+    ? `number\u0000${numberValueKey(term.name)}`
+    : `${term.type}\u0000${term.name}`;
+  _wfsScalarKeyCache.set(term, key);
+  return key;
 }
 
 function sameScalar(left, right) {

package/src/write.js

@@ -6,6 +6,13 @@ import {
 
 const graphicAtomCharacters = new Set('!#$&*+-./<=>?@^~\\'.split(''));
 const compactInfixOperators = new Set([':', '..']);
+const RE_LOWER_WORD = /^[a-z][A-Za-z0-9_]*$/;
+const RE_ALNUM_IDENT = /^[A-Za-z0-9_]$/;
+const RE_DIGITS_ONLY = /^\d+$/;
+const RE_LEGACY_VAR_W = /^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/;
+const RE_UPPER_IDENT_W = /^(?:_|[A-Z_][A-Za-z0-9_]*)$/;
+const RE_SANITIZE_W = /[^A-Za-z0-9_]/g;
+const RE_UPPER_START_W = /^[A-Z_]/;
 
 function quotedControlEscape(ch) {
   if (ch === '\x00') return '\\0\\';
@@ -38,7 +45,7 @@ function atomNeedsQuotes(name) {
   // be read as a bracketed comment and therefore still requires quoting.
   if (name === '.') return true;
   if (name.startsWith('/*')) return true;
-  if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return false;
+  if (RE_LOWER_WORD.test(name)) return false;
   for (const ch of name) if (!graphicAtomCharacters.has(ch)) return true;
   return false;
 }
@@ -80,12 +87,12 @@ function compactBoundaryNeedsSpace(left, right) {
   // neighbouring identifier/number token.  Most predefined word operators
   // are handled explicitly below; this also protects quoted/custom cases that
   // render without punctuation.
-  if (/^[A-Za-z0-9_]$/.test(a) && /^[A-Za-z0-9_]$/.test(b)) return true;
+  if (RE_ALNUM_IDENT.test(a) && RE_ALNUM_IDENT.test(b)) return true;
   return false;
 }
 
 function isWordOperatorToken(token) {
-  return /^[a-z][A-Za-z0-9_]*$/.test(token);
+  return RE_LOWER_WORD.test(token);
 }
 
 function compactPrefixOperator(token, argument) {
@@ -99,7 +106,7 @@ function compactPrefixOperator(token, argument) {
 }
 
 function quotedOperatorAfterNumericNeedsSpace(left, token) {
-  if (!token.startsWith("'") || !/^[0-9]+$/.test(left)) return false;
+  if (!token.startsWith("'") || !RE_DIGITS_ONLY.test(left)) return false;
   const value = Number(left);
   // `0'X` starts character-code notation and bases 2..36 start based-number
   // notation. Base 1 and values above 36 do not, so they need no layout
@@ -135,11 +142,11 @@ function legacyVariableToIso(name) {
 
 function writeVariable(name) {
   name = String(name ?? '');
-  if (/^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/.test(name)) return legacyVariableToIso(name);
-  if (/^(?:_|[A-Z_][A-Za-z0-9_]*)$/.test(name)) return name;
-  const sanitized = name.replace(/[^A-Za-z0-9_]/g, '_');
+  if (RE_LEGACY_VAR_W.test(name)) return legacyVariableToIso(name);
+  if (RE_UPPER_IDENT_W.test(name)) return name;
+  const sanitized = name.replace(RE_SANITIZE_W, '_');
   if (!sanitized) return '_';
-  return /^[A-Z_]/.test(sanitized) ? sanitized : `_${sanitized}`;
+  return RE_UPPER_START_W.test(sanitized) ? sanitized : `_${sanitized}`;
 }
 
 function writeString(value) {
@@ -157,7 +164,7 @@ function quotedListCharacter(item, doubleQuotes) {
     return item.name;
   }
   if (doubleQuotes === 'codes') {
-    if (item.type !== NUMBER || !/^\d+$/.test(item.name)) return null;
+    if (item.type !== NUMBER || !RE_DIGITS_ONLY.test(item.name)) return null;
     const code = BigInt(item.name);
     if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) return null;
     return String.fromCodePoint(Number(code));
@@ -197,7 +204,7 @@ function operatorName(name) {
   // output must use the unquoted `|` token (WG17 #181/#290).
   if (name === '|') return '|';
   if (name === '.' || name.startsWith('/*')) return quoteAtom(name);
-  if (/^[a-z][A-Za-z0-9_]*$/.test(name)) return name;
+  if (RE_LOWER_WORD.test(name)) return name;
   if (/^[!#$&*+\-./<=>?@^~\\;:]+$/.test(name)) return name;
   return quoteAtom(name);
 }
@@ -334,7 +341,7 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
 
   if (options.numbervars && resolved.type === COMPOUND && resolved.name === '$VAR' && resolved.arity === 1) {
     const index = deref(resolved.args[0], env);
-    if (index.type === NUMBER && /^\d+$/.test(index.name)) {
+    if (index.type === NUMBER && RE_DIGITS_ONLY.test(index.name)) {
       const name = writeNumberedVariable(Number(index.name));
       if (name != null) return name;
     }
@@ -404,7 +411,7 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
         const childNumbervar = options.numbervars && child.type === COMPOUND &&
           child.name === '$VAR' && child.arity === 1 && (() => {
             const index = deref(child.args[0], env);
-            return index.type === NUMBER && /^\d+$/.test(index.name) &&
+            return index.type === NUMBER && RE_DIGITS_ONLY.test(index.name) &&
               writeNumberedVariable(Number(index.name)) != null;
           })();
         const childUsesSpecialNotation = isCons(child) ||

package/test/bench/benchmarks.json

@@ -72,15 +72,6 @@
     ],
     "expectedSha256": "b4a153234f3daf1e2ba6c26843349a1bc1919ebd9f9e98559835eb5ef915716b"
   },
-  {
-    "name": "dcg-command",
-    "group": "dcg",
-    "file": "examples/dcg-command-parser.pl",
-    "goals": [
-      "dcg_example(X0, X1)"
-    ],
-    "expectedSha256": "6f640fb0d327eb9139d3568cf7a86ad55a52afdbb0208ca35a70419be2bf1b9c"
-  },
   {
     "name": "dcg-expression",
     "group": "dcg",
@@ -106,24 +97,6 @@
     ],
     "expectedSha256": "a7c33872b86aa7877b9c38ec41c447fc96a328d40f512428993d662f28a097ad"
   },
-  {
-    "name": "clpz-register-allocation",
-    "group": "clpz",
-    "file": "examples/register-allocation.pl",
-    "goals": [
-      "registerAnswer(X0, X1)"
-    ],
-    "expectedSha256": "1ed0b4a90deff2908463774d0025210d58b89366efb5d82b94ff5b51daca046b"
-  },
-  {
-    "name": "clpb-feature-model",
-    "group": "clpb",
-    "file": "examples/clpb-feature-model.pl",
-    "goals": [
-      "feature_plan(X0)"
-    ],
-    "expectedSha256": "47abfd8a87efb595ffb11c6c8cbda3cb5855e95124bc574e3cae387c12318f33"
-  },
   {
     "name": "attributed-variables",
     "group": "attributes",
@@ -190,5 +163,14 @@
       "type_answer(X0, X1)"
     ],
     "expectedSha256": "acad9ddb995d9ddef091e17cc91659d36ed7f9014d6714fd40100d85a53ae203"
+  },
+  {
+    "name": "bulk-stream-write",
+    "group": "term-io",
+    "file": "examples/bulk-stream-write.pl",
+    "goals": [
+      "bulk_write_result(X0, X1)"
+    ],
+    "expectedSha256": "8471da130a4a3a92dd31ee6cf285b1e129886177d7be367d51650a48b8920324"
   }
 ]

package/test/run-benchmark-tests.mjs

@@ -42,7 +42,7 @@ function runWorker(item) {
   ]);
 }
 
-ok(Array.isArray(manifest) && manifest.length === 21, 'benchmark manifest should contain exactly 21 representative workloads');
+ok(Array.isArray(manifest) && manifest.length === 19, 'benchmark manifest should contain exactly 19 representative workloads');
 ok(new Set(manifest.map((item) => item.name)).size === manifest.length, 'benchmark names should be unique');
 const classicNrev = manifest.find((item) => item.name === 'classic-nrev');
 ok(classicNrev?.logicalInferences === 496, 'classic nrev should retain the traditional 496-call LIPS accounting');
@@ -61,7 +61,7 @@ for (const item of manifest) {
 
 const adaptive = await spawnJson([
   path.join(root, 'test', 'benchmark.mjs'),
-  '--filter', 'dcg-command',
+  '--filter', 'dcg-expression',
   '--runs', '1',
   '--warmup', '0',
   '--target-ms', '50',
@@ -69,7 +69,7 @@ const adaptive = await spawnJson([
 ]);
 ok(adaptive.results.length === 1, 'adaptive benchmark smoke test should select one workload');
 ok(adaptive.results[0].batchSize > 1, 'adaptive benchmark smoke test should batch a short workload');
-ok(adaptive.results[0].sha256 === manifest.find((item) => item.name === 'dcg-command').expectedSha256,
+ok(adaptive.results[0].sha256 === manifest.find((item) => item.name === 'dcg-expression').expectedSha256,
   'adaptive batching should preserve the semantic checksum');
 
 const nrev = await spawnJson([

package/the-art-of-eyeprolog.md

@@ -5867,9 +5867,9 @@ and reports the portable ISO `type_error(list)` error term.
 #### A bidirectional expression grammar
 
 DCGs become more useful when the grammar produces a structured term rather than
-merely accepting a token list.  The checked
+merely accepting a token list. The checked
 [`dcg-expression-language.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/dcg-expression-language.pl)
-example implements a small arithmetic language in both directions.  Its parser
+example implements a small arithmetic language in both directions. Its parser
 respects precedence and left associativity while constructing an abstract syntax
 tree:
 
@@ -5887,17 +5887,17 @@ additive_tail(AST, AST) --> [].
 
 The accumulator removes left recursion without moving parsing into JavaScript.
 A second DCG walks the AST in the other direction and emits only the parentheses
-needed to preserve its structure.  The example therefore exercises parsing,
+needed to preserve its structure. The example therefore exercises parsing,
 semantic actions, nonterminal-to-nonterminal state hand-off, generation,
 backtracking, `phrase/3` remainder handling, and AST-to-token-to-AST
-round-tripping.  The checked answers are in
+round-tripping. The checked answers are in
 [`examples/output/dcg-expression-language.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/dcg-expression-language.pl).
 
 #### Deep sequence hand-off
 
 `library(iso_ext)` provides the common `... //0` helper, which describes an
-arbitrary number of input elements.  It is not part of ISO Part 3, but it is a
-useful interoperability and stress-test relation.  A compact hand-off test is:
+arbitrary number of input elements. It is not part of ISO Part 3, but it is a
+useful interoperability and stress-test relation. A compact hand-off test is:
 
 ```text
 a --> ..., epsilon.
@@ -5905,11 +5905,11 @@ epsilon --> [].
 ```
 
 Here the remaining sequence is repeatedly passed from `... //0` to another
-nonterminal.  For a finite compact list, EyeProlog can scan the arbitrary
+nonterminal. For a finite compact list, EyeProlog can scan the arbitrary
 sequence iteratively instead of consuming one ordinary solver depth level per
-list cell.  If the continuation is structurally proven to be a zero-width
+list cell. If the continuation is structurally proven to be a zero-width
 identity grammar such as `epsilon//0`, the hand-off can be continued without
-constructing a fresh general clause-resolution frame at every suffix.  The list
+constructing a fresh general clause-resolution frame at every suffix. The list
 spine is still traversed; this is a control/allocation optimization rather than
 an O(1) semantic shortcut.
 
@@ -6062,7 +6062,8 @@ contains 129 name/arity entries across 100 names.
 `;/2` recognizes an `->/2` term on its left and implements the ISO
 if-then-else commitment described above. Cuts and committed conditions are
 operational controls; use ordinary relations when all alternatives should
-remain observable. 
+remain observable.
+
 #### Definite clause grammar processing
 
 - **`phrase(+Body,?Sequence)`** — Parses or generates `Sequence` with a Part 3 grammar body and requires complete consumption.
@@ -9743,7 +9744,7 @@ Review questions:
 </figure>
 
 The [examples directory](https://github.com/eyereasoner/eyeprolog/tree/main/examples/) is the book's executable companion. The
-top-level directory contains **225 self-contained runnable programs**. Every
+top-level directory contains **226 self-contained runnable programs**. Every
 source program has an exact answer file under
 [examples/output](https://github.com/eyereasoner/eyeprolog/tree/main/examples/output/), and **61 selected programs** have a checked
 explanation under [examples/proof](https://github.com/eyereasoner/eyeprolog/tree/main/examples/proof/). The thematic lists link every top-level program and open the program
@@ -10176,7 +10177,7 @@ npm run benchmark:baseline
 npm run benchmark:lips
 ```
 
-The benchmark suite contains 21 representative workloads and stores their
+The benchmark suite contains 19 representative workloads and stores their
 semantic output digests in the repository, while wall-clock baselines remain
 machine-local under `.benchmarks/` because absolute timings are machine-specific.
 Each benchmark runs in its own fresh Node worker. Inside that worker, one untimed
@@ -10368,7 +10369,7 @@ specifications.
 
 - Kurt Gödel,
   [“Über formal unentscheidbare Sätze der *Principia Mathematica* und
-  verwandter Systeme I”](https://doi.org/10.1007/BF01700686),
+  verwandter Systeme I”](https://doi.org/10.1007/BF01700692),
   *Monatshefte für Mathematik und Physik* 38, 1931, pp. 173–198. The
   incompleteness theorems establish intrinsic limits for sufficiently
   expressive effectively axiomatized formal systems. Chapter 30 treats such