eyeprolog 1.5.34 → 1.5.36

package/package.json

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

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();
@@ -811,11 +817,14 @@ class Parser {
     let left = this.parsePrefixTerm(minPrecedence, allowBar, allowOperatorAtom);
     const leftIsBareOperatorAtom = initialWasCurrentOperator &&
       left.type === ATOM && left.name === initialOperatorName;
-    // Neumerkel syntax #379 (2026-09-03) pins a strict-ISO distinction for
-    // the processor-defined grammar-rule operator: `(-->)/2` is not an ISO
-    // predicate-indicator spelling.  Keep the ordinary profile permissive for
-    // existing DCG/module code; the moving ISO conformity gate runs strict.
-    if (this.strictIso && left.type === ATOM && left.name === '-->' &&
+    // Neumerkel syntax #379: the DCG rule operator `-->` is processor-defined
+    // and not an ISO predicate-indicator name.  A bare `-->` (not parenthesized)
+    // followed by `/` would be an invalid strict-ISO predicate indicator.
+    // However, `(-->)/2` is valid: the parentheses make `-->` an ordinary atom
+    // argument, and ISO 7.10.3 does not restrict which atoms may appear as the
+    // name in a Name/Arity indicator — only the write-term rules govern spelling.
+    // Only reject the bare-operator form so (-->)/2 succeeds per #379.
+    if (this.strictIso && leftIsBareOperatorAtom && left.name === '-->' &&
         this.operatorTokenName() === '/') {
       throw new Error(`parse line ${this.token.line}: operator atom --> is not permitted in a strict ISO predicate indicator`);
     }
@@ -1813,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

@@ -8,7 +8,11 @@ import {
 
 export function componentHasNegativeEdge(start, deps, negativeEdges) {
   const forward = reachableIndexes(start, deps);
-  const component = new Set([...forward].filter((index) => reachableIndexes(index, deps).has(start)));
+  // A node is in the same SCC as `start` iff it can also reach `start`.
+  // Rather than calling reachableIndexes() per-node (O(n^2)), compute the
+  // reverse-reachability set from `start` over the transposed graph once.
+  const backward = reachableIndexesTransposed(start, deps, forward);
+  const component = new Set([...forward].filter((index) => backward.has(index)));
   return negativeEdges.some(([from, to]) => component.has(from) && component.has(to));
 }
 
@@ -27,7 +31,8 @@ export function clauseIsDirectRecursive(clause, group) {
 
 export function componentHasCut(start, deps, groups) {
   const forward = reachableIndexes(start, deps);
-  const component = [...forward].filter((index) => reachableIndexes(index, deps).has(start));
+  const backward = reachableIndexesTransposed(start, deps, forward);
+  const component = [...forward].filter((index) => backward.has(index));
   return component.some((index) => {
     const group = groups[index];
     const directRecursive = group.clauses.some((clause) => clauseIsDirectRecursive(clause, group));
@@ -50,6 +55,36 @@ export function reachableIndexes(start, deps) {
   return seen;
 }
 
+// Returns the set of nodes in `candidates` that can reach `target` by
+// traversing `deps` in reverse.  This is equivalent to asking which nodes
+// in the forward-reachable set from `target` also have `target` in their
+// own forward-reachable set, but computed in a single BFS over the
+// transposed graph rather than one BFS per candidate node.
+function reachableIndexesTransposed(target, deps, candidates) {
+  // Build a transposed adjacency list restricted to the candidate set.
+  const reverse = new Map();
+  for (const from of candidates) {
+    if (!reverse.has(from)) reverse.set(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); }
+      bucket.push(from);
+    }
+  }
+  const seen = new Set();
+  const stack = [target];
+  while (stack.length) {
+    const current = stack.pop();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    for (const prev of reverse.get(current) ?? []) if (!seen.has(prev)) stack.push(prev);
+  }
+  return seen;
+}
+
 
 export function isFiniteDatalogArgument(term) {
   return term?.type === VAR || term?.type === ATOM || term?.type === 'string' || term?.type === 'number';

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/solver.js

@@ -2,7 +2,7 @@
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
   ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
-  flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
+  flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList, isScalar,
   numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { numberValueKey, sameNumberValue } from './number-value.js';
@@ -2692,11 +2692,14 @@ function matchScalarFact(goal, head, env) {
 
 function derefScalarMatch(term, env, names, values) {
   let current = term;
-  for (let guard = 0; current?.type === 'var' && guard < 128; guard++) {
+  const seen = new Set();
+  while (current?.type === 'var') {
+    if (seen.has(current.name)) break;
+    seen.add(current.name);
     const localIndex = names.indexOf(current.name);
-    if (localIndex >= 0) current = values[localIndex];
-    else if (env.has(current.name)) current = env.get(current.name);
-    else break;
+    if (localIndex >= 0) { current = values[localIndex]; continue; }
+    if (env.has(current.name)) { current = env.get(current.name); continue; }
+    break;
   }
   return current;
 }
@@ -3092,12 +3095,11 @@ function matchGroundBinaryClause(goal, clause) {
   return { nextGoal: compound(bodyGoal.name, bodyArgs) };
 }
 
-function isScalarTerm(term) {
-  return term && (term.type === 'atom' || term.type === 'string' || term.type === 'number');
-}
+// isScalar is imported from term.js; use it as the canonical scalar test.
+const isScalarTerm = isScalar;
 
 function sameScalarTerm(left, right) {
-  return isScalarTerm(left) && isScalarTerm(right) && left.type === right.type &&
+  return isScalar(left) && isScalar(right) && left.type === right.type &&
     (left.type === 'number' ? sameNumberValue(left.name, right.name) : left.name === right.name);
 }
 
@@ -3131,9 +3133,9 @@ function sameResolvedGroundTerm(left, right, env) {
 
 function groundChainKey(term) {
   if (term?.type === COMPOUND) {
-    let out = `${term.name}/${term.arity}`;
-    for (let i = 0; i < term.arity; i++) out += `${groundChainKey(term.args[i])}`;
-    return out;
+    const parts = [`${term.name}/${term.arity}`];
+    for (let i = 0; i < term.arity; i++) parts.push(groundChainKey(term.args[i]));
+    return parts.join('');
   }
   return `${term?.type ?? ''}:${term?.name ?? ''}`;
 }

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

@@ -5,8 +5,14 @@ import {
 } from './term.js';
 
 const graphicAtomCharacters = new Set('!#$&*+-./<=>?@^~\\'.split(''));
-const dottedGraphicAtomCharacters = graphicAtomCharacters;
 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\\';
@@ -39,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;
 }
@@ -60,7 +66,7 @@ function writeAtom(name) {
 
 function isDottedGraphicAtom(name) {
   return name.includes('.') && [...name].some((ch) => ch !== '.') && !name.startsWith('/*') &&
-    [...name].every((ch) => dottedGraphicAtomCharacters.has(ch));
+    [...name].every((ch) => graphicAtomCharacters.has(ch));
 }
 
 function compactBoundaryNeedsSpace(left, right) {
@@ -81,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) {
@@ -100,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
@@ -136,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) {
@@ -158,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));
@@ -198,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);
 }
@@ -335,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;
     }
@@ -405,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/run-neumerkel-tests.mjs

@@ -59,13 +59,16 @@ export function runNeumerkelHarnessTests(reporter = new TestReporter()) {
     }
   });
 
-  reporter.test('latest strict syntax rejects Neumerkel #379 operator indicator', () => {
+  reporter.test('latest strict syntax allows Neumerkel #379 parenthesized --> atom', () => {
+    // Upstream Codex expectation for #379: writeq((-->)/2). -> (-->)/2
+    // (-->)/2 is valid: parentheses make --> an ordinary atom; only bare
+    // --> followed by / in a predicate indicator is processor-defined syntax.
     const item = {
       id: 379,
       query: 'writeq((-->)/2).',
       input: 'writeq((-->)/2).',
       readCount: 1,
-      expected: 'syntax err.',
+      expected: '(-->)/2',
     };
     const actual = executeWg17Item(item);
     if (!matchesUpstreamExpectation(item.expected, actual, item)) {

package/test/run-regression.mjs

@@ -1956,8 +1956,10 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'ISO predicate indicators require parentheses around operator atoms',
+      name: 'ISO predicate indicators require parentheses around bare operator atoms',
       run: () => {
+        // Bare --> /2 (without parens) is still rejected in all modes because
+        // --> is an infix/prefix operator atom that cannot appear as a bare operand.
         let caught = null;
         try {
           parseGoalText('writeq(--> /2)');
@@ -1966,20 +1968,22 @@ c4 ?- call((!;1)).
         }
         if (!caught) throw new Error('bare operator predicate indicator unexpectedly parsed');
         assertIncludes(caught.message, 'operator atom', 'bare indicator syntax rejection');
+        // (-->)/2 with parentheses is legal in both normal and strict ISO modes.
+        // Neumerkel #379: upstream Codex expectation is (-->)/2 -> (-->)/2 (success).
+        // Parentheses make --> an ordinary atom argument; ISO 7.10.3 does not
+        // restrict which atoms may appear as the name in a Name/Arity indicator.
         parseGoalText('writeq((-->)/2)');
         assertEqual(
           run('', { goal: 'writeq((-->)/2)' }).stdout,
           '(-->)/2writeq((-->) / 2).\n',
           'parenthesized operator indicator stays legal outside strict ISO',
         );
-        caught = null;
-        try {
-          parseGoalText('writeq((-->)/2)', { isoStrict: true });
-        } catch (error) {
-          caught = error;
-        }
-        if (!caught) throw new Error('Neumerkel #379 strict indicator unexpectedly parsed');
-        assertIncludes(caught.message, 'strict ISO predicate indicator', 'Neumerkel #379 strict syntax rejection');
+        parseGoalText('writeq((-->)/2)', { isoStrict: true });
+        assertEqual(
+          run('', { isoStrict: true, goal: 'writeq((-->)/2)' }).stdout,
+          '(-->)/2writeq((-->) / 2).\n',
+          'Neumerkel #379: parenthesized --> is legal in strict ISO',
+        );
       },
     },
     {