eyeprolog 1.5.22 → 1.5.24

package/conformance-report.md

@@ -8,9 +8,9 @@ when this report is generated; it is not inferred from fixture counts.
 
 | Gate | Passed | Total | Status |
 |---|---:|---:|---|
-| WG17 syntax | 372 | 372 | pass |
+| WG17 syntax | 366 | 366 | pass |
 
-The WG17 syntax row executes the vendored 372-case conformity-testing matrix
+The WG17 syntax row executes the vendored 366-case conformity-testing matrix
 against EyeProlog's strict ISO reader/writer. A behavior fix such as operator-token
 spelling therefore changes this report even when no corpus file is added or removed.
 

package/package.json

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

package/src/iso.js

@@ -1762,7 +1762,7 @@ function parseReadTermText(text, solver) {
   const numericText = converted.slice(0, -1).replace(/[\u0009-\u000d\u0020]+$/, '');
   let numericTerm;
   try {
-    numericTerm = parseIsoNumber(numericText);
+    numericTerm = parseIsoNumber(numericText, { isoStrict: solver.isoStrict });
   } catch (error) {
     // parseIsoNumber/1 exposes Prolog errors to number_chars/2. The stream
     // reader's candidate loop instead recognizes parser representation errors
@@ -2338,7 +2338,7 @@ function quotedNumberSign(text, start) {
   return null;
 }
 
-function parseIsoNumber(text) {
+function parseIsoNumber(text, options = {}) {
   if (text.length === 0) return null;
   let position = skipNumberLayout(text, 0);
   let sign = '';
@@ -2375,7 +2375,7 @@ function parseIsoNumber(text) {
   // ISO floating-point syntax requires a decimal fraction before an exponent.
   if (/^-?\d+[eE][+-]?\d+$/.test(numericText)) return null;
   try {
-    const value = parseNumberTokenText(numericText);
+    const value = parseNumberTokenText(numericText, options);
     if (isDecimalInteger(value.name)) return numberTerm(BigInt(value.name).toString());
     const finite = Number(value.name);
     if (!Number.isFinite(finite)) return null;
@@ -2447,7 +2447,7 @@ function numberListBuiltin(kind) {
     const text = numberListText(list, env, kind, value.type === NUMBER, solver);
     if (value.type === NUMBER) {
       if (text != null) {
-        const parsed = parseIsoNumber(text);
+        const parsed = parseIsoNumber(text, { isoStrict: solver?.isoStrict === true });
         if (parsed == null) throw numberSyntaxError;
         if (sameNumber(value, parsed)) yield env.clone();
         return;
@@ -2458,7 +2458,7 @@ function numberListBuiltin(kind) {
       if (unify(goal.args[1], listFromItems(items), next)) yield next;
       return;
     }
-    const parsed = parseIsoNumber(text);
+    const parsed = parseIsoNumber(text, { isoStrict: solver?.isoStrict === true });
     if (parsed == null) throw numberSyntaxError;
     const next = env.clone();
     if (unify(goal.args[0], parsed, next)) yield next;

package/src/parser.js

@@ -439,6 +439,21 @@ class Parser {
       break;
     }
   }
+  integerDigits(digitPattern, line) {
+    let digits = '';
+    let separated = false;
+    while (digitPattern.test(this.peek())) {
+      digits += this.take();
+      if (this.strictIso || this.peek() !== '_') continue;
+      separated = true;
+      this.take();
+      this.skipWhitespaceAndComments();
+      if (!digitPattern.test(this.peek())) {
+        throw new Error(`parse line ${line}: bad digit separator`);
+      }
+    }
+    return { digits, separated };
+  }
   readEscape(line, options = {}) {
     const takeChar = () => options.raw ? this.rawTake() : this.take();
     const peekChar = () => options.raw ? this.rawPeek() : this.peek();
@@ -646,17 +661,16 @@ class Parser {
         const kind = this.take();
         const radix = kind === 'b' ? 2 : kind === 'o' ? 8 : 16;
         const digitPattern = radix === 2 ? /^[01]$/ : radix === 8 ? /^[0-7]$/ : /^[0-9A-Fa-f]$/;
-        let digits = '';
-        while (digitPattern.test(this.peek())) digits += this.take();
+        const { digits } = this.integerDigits(digitPattern, line);
         if (!digits) throw new Error(`parse line ${line}: bad radix integer`);
         let integer = 0n;
         for (const digit of digits) integer = integer * BigInt(radix) + BigInt(Number.parseInt(digit, radix));
         if (negative) integer = -integer;
         return { type: TOK.NUMBER, text: integer.toString(), line };
       }
-      while (isDigitCode(this.peek().charCodeAt(0))) this.take();
+      const { digits, separated } = this.integerDigits(/^[0-9]$/, line);
       let hasFraction = false;
-      if (this.peek() === '.' && isDigitCode(this.peek(1).charCodeAt(0))) {
+      if (!separated && this.peek() === '.' && isDigitCode(this.peek(1).charCodeAt(0))) {
         hasFraction = true;
         this.take();
         while (isDigitCode(this.peek().charCodeAt(0))) this.take();
@@ -674,7 +688,7 @@ class Parser {
         }
       }
       let text = this.convertedSlice(start, this.pos);
-      if (!hasFraction) text = BigInt(text).toString();
+      if (!hasFraction) text = BigInt(`${negative ? '-' : ''}${digits}`).toString();
       else text = finiteFloatTokenText(text);
       return { type: TOK.NUMBER, text, line };
     }
@@ -1704,8 +1718,43 @@ export function parseProgramText(source, options = {}) {
 
 const invalidNumberTokenError = new Error('not exactly one number token');
 
-export function parseNumberTokenText(text) {
+function skipDigitSeparatorLayout(source, start) {
+  let position = start;
+  while (true) {
+    while (isWhitespaceCharacter(source[position] ?? '')) position++;
+    if (source[position] === '%') {
+      const newline = source.indexOf('\n', position + 1);
+      if (newline < 0) return source.length;
+      position = newline + 1;
+      continue;
+    }
+    if (source.startsWith('/*', position)) {
+      const end = source.indexOf('*/', position + 2);
+      if (end < 0) return source.length;
+      position = end + 2;
+      continue;
+    }
+    return position;
+  }
+}
+
+function separatedIntegerDigits(source, start, digitPattern, enabled) {
+  let position = start;
+  let digits = '';
+  let separated = false;
+  while (digitPattern.test(source[position] ?? '')) {
+    digits += source[position++];
+    if (!enabled || source[position] !== '_') continue;
+    separated = true;
+    position = skipDigitSeparatorLayout(source, position + 1);
+    if (!digitPattern.test(source[position] ?? '')) throw invalidNumberTokenError;
+  }
+  return { digits, position, separated };
+}
+
+export function parseNumberTokenText(text, options = {}) {
   const source = String(text ?? '');
+  const digitSeparators = options.isoStrict !== true;
   let position = 0;
   let negative = false;
   if (source[position] === '-') {
@@ -1771,8 +1820,9 @@ export function parseNumberTokenText(text) {
     const radix = kind === 'b' ? 2 : kind === 'o' ? 8 : 16;
     const digitPattern = radix === 2 ? /^[01]$/ : radix === 8 ? /^[0-7]$/ : /^[0-9A-Fa-f]$/;
     position += 2;
-    let digits = '';
-    while (digitPattern.test(source[position] ?? '')) digits += source[position++];
+    const scanned = separatedIntegerDigits(source, position, digitPattern, digitSeparators);
+    const { digits } = scanned;
+    position = scanned.position;
     if (!digits || position !== source.length) throw invalidNumberTokenError;
     let integer = 0n;
     for (const digit of digits) integer = integer * BigInt(radix) + BigInt(Number.parseInt(digit, radix));
@@ -1780,11 +1830,12 @@ export function parseNumberTokenText(text) {
     return numberTerm(integer.toString());
   }
 
-  const digitsStart = position;
-  while (isDigitCode(source.charCodeAt(position))) position++;
-  if (position === digitsStart) throw invalidNumberTokenError;
+  const scanned = separatedIntegerDigits(source, position, /^[0-9]$/, digitSeparators);
+  const { digits, separated } = scanned;
+  position = scanned.position;
+  if (!digits) throw invalidNumberTokenError;
   let hasFraction = false;
-  if (source[position] === '.' && isDigitCode(source.charCodeAt(position + 1))) {
+  if (!separated && source[position] === '.' && isDigitCode(source.charCodeAt(position + 1))) {
     hasFraction = true;
     position++;
     while (isDigitCode(source.charCodeAt(position))) position++;
@@ -1797,7 +1848,7 @@ export function parseNumberTokenText(text) {
     if (position === exponentStart) throw invalidNumberTokenError;
   }
   if (position !== source.length) throw invalidNumberTokenError;
-  if (/^-?\d+$/.test(source)) return numberTerm(BigInt(source).toString());
+  if (!hasFraction) return numberTerm(BigInt(`${negative ? '-' : ''}${digits}`).toString());
   return numberTerm(finiteFloatTokenText(source));
 }
 

package/test/benchmark.mjs

@@ -128,6 +128,48 @@ function changeText(item) {
   return `${change < 0 ? '↓' : '↑'} ${value}`;
 }
 
+function summarizeResults(results) {
+  const comparable = results.filter((item) =>
+    Number.isFinite(item.medianMs) &&
+    item.medianMs > 0 &&
+    Number.isFinite(item.baselineMs) &&
+    item.baselineMs > 0);
+
+  if (comparable.length === 0) {
+    return {
+      comparable: 0,
+      total: results.length,
+      ratio: null,
+      changePercent: null,
+      currentTotalMs: null,
+      baselineTotalMs: null,
+      totalRatio: null,
+      totalChangePercent: null,
+    };
+  }
+
+  const ratio = Math.exp(
+    comparable.reduce(
+      (sum, item) => sum + Math.log(item.medianMs / item.baselineMs),
+      0,
+    ) / comparable.length,
+  );
+  const currentTotalMs = comparable.reduce((sum, item) => sum + item.medianMs, 0);
+  const baselineTotalMs = comparable.reduce((sum, item) => sum + item.baselineMs, 0);
+  const totalRatio = currentTotalMs / baselineTotalMs;
+
+  return {
+    comparable: comparable.length,
+    total: results.length,
+    ratio,
+    changePercent: (ratio - 1) * 100,
+    currentTotalMs,
+    baselineTotalMs,
+    totalRatio,
+    totalChangePercent: (totalRatio - 1) * 100,
+  };
+}
+
 function runWorker(item) {
   const child = spawnSync(process.execPath, [
     path.join(root, 'test', 'benchmark-worker.mjs'),
@@ -176,6 +218,8 @@ for (const item of selected) {
   });
 }
 
+const summary = summarizeResults(results);
+
 if (options.save != null) {
   await fs.mkdir(path.dirname(options.save), { recursive: true });
   const saved = {
@@ -202,6 +246,7 @@ if (options.json) {
     targetMs: options.targetMs,
     baseline: baselinePath,
     baselineWarning,
+    summary,
     results,
   }, null, 2)}\n`);
 } else {
@@ -220,9 +265,25 @@ if (options.json) {
   printRow(headers);
   printRow(widths.map((width) => '-'.repeat(width)));
   for (const row of rows) printRow(row);
+
+  if (summary.comparable > 0) {
+    process.stdout.write(
+      `\nSuite score: ${summary.ratio.toFixed(3)}x baseline ` +
+      `(${changeText({ changePercent: summary.changePercent })}); ` +
+      `equal-weight geometric mean across ${summary.comparable}/${summary.total} comparable benchmarks.\n`,
+    );
+    process.stdout.write(
+      `Time-weighted total: ${formatMs(summary.currentTotalMs)} vs ${formatMs(summary.baselineTotalMs)} ` +
+      `(${changeText({ changePercent: summary.totalChangePercent })}).\n`,
+    );
+  }
+
   process.stdout.write(`\n${results.length} benchmarks; ${options.runs} measured batch${options.runs === 1 ? '' : 'es'} each after ${options.warmup} warm-up batch${options.warmup === 1 ? '' : 'es'}, calibrated after one priming execution toward ${options.targetMs} ms per batch.\n`);
   if (baselineWarning) process.stdout.write(`${baselineWarning}\n`);
   if (baselinePath == null && !baselineWarning) process.stdout.write('No timing baseline found; run npm run benchmark:baseline to create .benchmarks/baseline.json.\n');
   if (options.save != null) process.stdout.write(`Saved timing baseline: ${path.relative(root, options.save)}\n`);
   process.stdout.write('Change compares the current median/op directly with the saved baseline median/op; the measured range is shown separately.\n');
+  if (summary.comparable > 0) {
+    process.stdout.write('Suite score is the geometric mean of current/baseline ratios, so every benchmark has equal relative weight; Time-weighted total compares summed medians and is dominated by longer workloads.\n');
+  }
 }

package/test/conformance/ISO-COMPLIANCE.md

@@ -19,7 +19,7 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 
 | Requirement | Status | EyeProlog evidence / remaining work |
 | --- | --- | --- |
-| 5.1(a) prepare conforming Prolog text | covered | Clause 6 token/term production and rejection families are mapped by the strict production gate and the complete 372-case vendored WG17 syntax matrix; 7.4 preparation/directive behavior is separately closed. |
+| 5.1(a) prepare conforming Prolog text | covered | Clause 6 token/term production and rejection families are mapped by the strict production gate and the complete 366-case vendored WG17 syntax matrix; 7.4 preparation/directive behavior is separately closed. |
 | 5.1(b) execute conforming Prolog goals | covered | Clause 7 term/control/execution semantics, the higher-level 7.10 stream model, 7.11 flags, the 7.12 error envelope, all 8.2-8.17 built-in rows, and Clause 9 arithmetic have explicit executable dispositions. |
 | 5.1(c) reject nonconforming text/read-terms | covered | WG17 negative syntax cases, focused malformed-production/escape/comment/operator cases, read-term syntax errors, and strict rejection of implementation-specific syntax provide explicit rejection evidence across the Clause 6 families. |
 | 5.1(d) document permitted variations | covered | The clause-by-clause [ISO 5.4 decision index](ISO-IMPLEMENTATION-DEFINED.md) records every explicit implementation-defined decision found in the Part 1 + Corrigenda baseline and separately inventories implementation-specific extension families. The index retains an `audit gap` category for future discoveries; no current release-facing row depends on one. |
@@ -31,7 +31,7 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | covered | The strict Clause 6 gate maps atomic/variable/compound/operator/list/curly/double-quoted term forms, layout/comments, quoted escapes, integer bases/character codes, floating tokens, and solo/meta token boundaries, with malformed counterparts rejected. The complete 372-case WG17 syntax matrix provides independent production-level coverage, and a cross-profile gate verifies that normal syntax extensions preserve every strict-accepted standard observation. The implementation-defined 6.5/6.6 PCS/collation choices are documented separately. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | covered | The strict Clause 6 gate maps atomic/variable/compound/operator/list/curly/double-quoted term forms, layout/comments, quoted escapes, integer bases/character codes, floating tokens, and solo/meta token boundaries, with malformed counterparts rejected. The complete 366-case WG17 syntax matrix provides independent production-level coverage, and a cross-profile gate verifies that normal syntax extensions preserve every strict-accepted standard observation. The implementation-defined 6.5/6.6 PCS/collation choices are documented separately. |
 | 7.1-7.3 — term types, term order, unification | covered | [ISO-TERM-SEMANTICS-MATRIX.md](ISO-TERM-SEMANTICS-MATRIX.md) records the five mutually exclusive strict term types, derived variable/compound/list notions, the complete standard-order classes and implementation-dependent variable-order choice, NSTO MGU/failure behavior, and EyeProlog's permitted consistent occurs-check failure for Part 1's undefined STO ordinary-unification cases. The normal JavaScript API string term is documented as a 5.5.4 extension and rejected at strict program/goal entry. |
 | 7.4 — Prolog text and directives | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes the preparation/directive rows: declaration semantics, source clauses, cross-text operators/character conversion/flags, initialization order/lifetime, `include/1`, and one-time `ensure_loaded/1`, with implementation-defined cross-text choices indexed under 5.4. |
 | 7.5-7.6 — database and term/clause conversion | covered | [ISO-PROLOG-TEXT-EXECUTION-MATRIX.md](ISO-PROLOG-TEXT-EXECUTION-MATRIX.md) closes static/dynamic and private/public procedure semantics, clause order, logical-update visibility, empty/unknown lifetime, and term/body/clause conversion. Source and runtime assertion conversion recurse through `,/2`, `;/2`, and `->/2`, preserve variable identity, and protect standardized static/control procedures. |
@@ -286,7 +286,7 @@ post-N289 STC drafts remain review input until standardized.
 | Criterion | Status | Evidence |
 | --- | --- | --- |
 | Clause 5 processor obligations have explicit dispositions | covered | `ISO-PROCESSOR-REQUIREMENTS.md` gives explicit outcomes for 5.1-5.5, including the strict/normal extension boundary. |
-| Clause 6 lexical/syntactic requirements have explicit dispositions | covered | the strict Clause 6 production/rejection gate and the 372-case vendored WG17 matrix cover the standard families; cross-profile preservation verifies that normal extensions do not reinterpret strict-accepted text. |
+| Clause 6 lexical/syntactic requirements have explicit dispositions | covered | the strict Clause 6 production/rejection gate and the 366-case vendored WG17 matrix cover the standard families; cross-profile preservation verifies that normal extensions do not reinterpret strict-accepted text. |
 | Clause 7 semantic requirements have explicit dispositions | covered | 7.1-7.12 now have explicit semantic, implementation-defined, or error-envelope dispositions backed by strict tests and the specialized matrices. |
 | Clause 8 built-in modes/errors have explicit dispositions | covered | `ISO-BUILTIN-MODE-ERROR-MATRIX.md` closes 8.2-8.17 row by row |
 | Clause 9 evaluable-functor requirements have explicit dispositions | covered | `ISO-EVALUABLE-FUNCTOR-MATRIX.md` plus the strict arithmetic regression closes the published Part 1 + Corrigenda arithmetic rows |
@@ -294,7 +294,7 @@ post-N289 STC drafts remain review input until standardized.
 | Implementation-specific strict/normal boundary is documented and tested | covered | all 5.5 hooks have explicit dispositions; the WG17 cross-profile gate verifies syntax-preservation for standard text accepted by the strict reader. |
 | Published Corrigenda 1-3 are incorporated | covered | dedicated conformance/strict tests and this ledger track all three published Corrigenda |
 | Current post-N289 draft is tracked without silently changing the published baseline | covered | `STC-DRAFT-STATUS.md` tracks reviewed draft items separately from normative requirements |
-| Independent external syntax corpus is an offline release gate | covered | the vendored WG17 syntax matrix has 372 executable dispositions checked against its upstream expectations |
+| Independent external syntax corpus is an offline release gate | covered | the vendored WG17 syntax matrix has 366 executable dispositions checked against its upstream expectations |
 | Third-party standard-core regression provenance is retained | covered | adapted Logtalk, Scryer, Trealla, and SWI-Prolog cases retain source identifiers and licenses in `THIRD_PARTY.md` |
 | No unexplained deviation remains in the release-facing ledger | covered | the release-facing ledger contains no remaining `audit` rows; documented variation points are implementation-defined/specific or draft-only rather than unexplained deviations. |
 

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -113,7 +113,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 
 | Part 1 extension hook | EyeProlog normal-profile feature | Strict-core disposition |
 | --- | --- | --- |
-| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, embedded quad syntax, and Trealla-compatible `"text"||Tail` right-splicing for double-quoted `chars`/`codes` lists | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax and double-bar right-splicing are rejected. Unicode PCS membership/classification is implementation defined and therefore shared with normal mode rather than treated as an extension. |
+| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, embedded quad syntax, digit-separated integer constants (`1_000`, `0xCA_FE`, with optional layout after `_`), and Trealla-compatible `"text"||Tail` right-splicing for double-quoted `chars`/`codes` lists | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax, integer digit separators, and double-bar right-splicing are rejected. Unicode PCS membership/classification is implementation defined and therefore shared with normal mode rather than treated as an extension. |
 | 5.5.2 Predefined operators | Part 3 `|` and EyeProlog's labelable infix `(?-)/2`; CLP(Z) operators when that library is imported | Only the Part 1 operator table is predefined; a conforming `op/3` may still add permitted operators. |
 | 5.5.3 Character-conversion mapping | No non-identity initial `Convc` extension | Identity initial mapping. |
 | 5.5.4 Types | The normal JavaScript API exposes an implementation-specific string term `stringTerm(Text)`. It is disjoint from the five Part 1 term types; normal term order places it after atoms and before compound terms, and normal `atomic/1` treats it as atomic. It has no Prolog source token syntax (double-quoted source still follows `double_quotes`), is non-callable for term-to-clause conversion, is not evaluable as an arithmetic expression, and writes as a double-quoted host string. | Strict mode rejects a programmatic string term at program/goal entry with `representation_error(term)`, so the additional type cannot enter the Part 1 execution domain. **defined** — `src/term.js`, `src/program.js`, `src/solver.js`; strict API-boundary regression. |

package/test/conformance/ISO-PROCESSOR-REQUIREMENTS.md

@@ -34,7 +34,7 @@ certification claim.
 | Requirement | Status | EyeProlog decision / evidence |
 | --- | --- | --- |
 | 5.5 general extension rule | covered | normal mode may provide documented extensions; strict mode removes their Part 1 interpretation rather than changing implementation-defined choices |
-| 5.5.1 syntax extensions preserve standard token/text meaning | covered | WG17 syntax is a release gate and strict mode removes module/DCG/quad interpretation. Every vendored WG17 case that succeeds in the strict reader has the same observable outcome in normal mode; the focused Clause 6 gate separately covers each standard token/term family and malformed counterparts. |
+| 5.5.1 syntax extensions preserve standard token/text meaning | covered | WG17 syntax is a release gate and strict mode removes module/DCG/quad, digit-separator, and double-bar interpretation. Every vendored WG17 case that succeeds in the strict reader has the same observable outcome in normal mode; the focused Clause 6 gate separately covers each standard token/term family and malformed counterparts. |
 | 5.5.2 additional predefined operators | covered | strict mode starts from the Part 1 predefined operator table; normal-profile extra operators are documented and filtered |
 | 5.5.3 initial character-conversion mapping | covered | identity initial mapping; user changes are exercised through preparation/execution `char_conversion/2` behavior |
 | 5.5.4 additional term types | covered | the normal JavaScript API's `stringTerm(Text)` is documented as an implementation-specific sixth term type, including disjointness, ordering, clause conversion, lack of source token syntax, expression behavior, and writing; strict program/goal entry rejects that type with `representation_error(term)` |

package/test/conformance/README.md

@@ -145,7 +145,7 @@ are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
 The corpus has 386 cases in `iso/` and 802 file-based conformance cases in
 total. Of those, 11 cases in `stc/` are explicitly labelled working-draft
-review evidence rather than normative ISO claims. The separate strict-reader WG17 matrix has 372 executable dispositions.
+review evidence rather than normative ISO claims. The separate strict-reader WG17 matrix has 366 executable dispositions.
 The generated `conformance-report.md` is the authoritative source for the current
 executable WG17 syntax result and file-based category totals. Together with regression, documentation-sync, API, example,
 and book-example checks, `npm test` is the release gate.

package/test/conformance/WG17-SYNTAX-STATUS.md

@@ -1,7 +1,7 @@
 # WG17 syntax traceability status
 
 Source: [Conformity Testing I: Syntax](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing)  
-Upstream inventory checked: 2026-08-28
+Upstream inventory checked: 2026-09-01
 
 This ledger counts an upstream case when its WG17 identifier, query, and
 expected ISO disposition are stored in the offline executable matrix. Every
@@ -20,25 +20,25 @@ A represented case still has to pass the executable upstream assertion in
 
 | Measure | Count |
 | --- | ---: |
-| Active upstream cases | 372 |
-| Upstream cases represented in the executable matrix | 372 (100.0%) |
+| Active upstream cases | 366 |
+| Upstream cases represented in the executable matrix | 366 (100.0%) |
 | Not yet traced one-by-one | 0 |
 | Deleted upstream identifiers | #20, #273 |
 
 The matrix runs in strict ISO stream-reader mode as part of `npm test`. The
 3 upstream `waits` cases are checked through EyeProlog's interactive input
-hook. All 372 executable cases are independently checked against the
-upstream Codex expectation. 372 cases additionally retain exact reviewed
-outcomes for stronger regression checking; 0 cases currently rely on the upstream assertion alone.
+hook. All 366 executable cases are independently checked against the
+upstream Codex expectation. 365 cases additionally retain exact reviewed
+outcomes for stronger regression checking; 1 case currently relies on the upstream assertion alone.
 
 ## Traceable evidence
 
 | Executable evidence | Referenced IDs | WG17 cases |
 | --- | ---: | --- |
-| [complete offline executable matrix](../run-wg17.mjs) | 372 | #1–#19, #21–#272, #274–#374 |
+| [complete offline executable matrix](../run-wg17.mjs) | 366 | #1–#19, #21–#272, #274–#368 |
 
-The evidence groups overlap. Their union is **372** active cases:
-#1–#19, #21–#272, #274–#374.
+The evidence groups overlap. Their union is **366** active cases:
+#1–#19, #21–#272, #274–#368.
 
 ## Untraced upstream identifiers
 

package/test/conformance/wg17-syntax-cases.json

@@ -1,6 +1,6 @@
 {
   "source": "https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing",
-  "checkedOn": "2026-08-16",
+  "checkedOn": "2026-09-01",
   "protocol": "Each query is read and executed in strict ISO mode; /**/ rows reuse the preceding setup.",
   "cases": [
     {
@@ -4139,16 +4139,8 @@
       "query": "write_canonical(B+B).",
       "input": "write_canonical(B+B).",
       "readCount": 1,
-      "expected": "e.g. +(_1,\n_1)",
-      "outcome": {
-        "type": "success",
-        "stages": [
-          {
-            "output": "+(_A,_A)",
-            "variables": "['B'=B]"
-          }
-        ]
-      }
+      "expected": "e.g. +(_1,_1)",
+      "assertion": "upstream"
     },
     {
       "id": 228,
@@ -5565,99 +5557,8 @@
           }
         ]
       }
-    },
-    {
-      "id": 369,
-      "query": "writeq(?-).",
-      "input": "writeq(?-).",
-      "readCount": 1,
-      "expected": "?-",
-      "outcome": {
-        "type": "success",
-        "stages": [
-          {
-            "output": "?-",
-            "variables": "[]"
-          }
-        ]
-      }
-    },
-    {
-      "id": 370,
-      "query": "writeq(./*).",
-      "input": "writeq(./*).",
-      "readCount": 1,
-      "expected": "./*",
-      "outcome": {
-        "type": "success",
-        "stages": [
-          {
-            "output": "./*",
-            "variables": "[]"
-          }
-        ]
-      }
-    },
-    {
-      "id": 371,
-      "query": "writeq({*}).",
-      "input": "writeq({*}).",
-      "readCount": 1,
-      "expected": "{*}",
-      "outcome": {
-        "type": "success",
-        "stages": [
-          {
-            "output": "{*}",
-            "variables": "[]"
-          }
-        ]
-      }
-    },
-    {
-      "id": 372,
-      "query": "writeq(.*).",
-      "input": "writeq(.*).",
-      "readCount": 1,
-      "expected": ".*",
-      "outcome": {
-        "type": "success",
-        "stages": [
-          {
-            "output": ".*",
-            "variables": "[]"
-          }
-        ]
-      }
-    },
-    {
-      "id": 373,
-      "query": "writeq(...*).",
-      "input": "writeq(...*).",
-      "readCount": 1,
-      "expected": "...*",
-      "outcome": {
-        "type": "success",
-        "stages": [
-          {
-            "output": "...*",
-            "variables": "[]"
-          }
-        ]
-      }
-    },
-    {
-      "id": 374,
-      "query": "Finis ().",
-      "input": "Finis ().",
-      "readCount": 1,
-      "expected": "syntax err.",
-      "outcome": {
-        "type": "error",
-        "formal": "syntax_error(read_term)"
-      }
     }
   ],
   "sourceRevision": "1.300",
-  "sourceSha256": "d7ca05e90cfafe786d5edca4783e691a356a35508c50b62f5a99bd9057e2cd05"
+  "sourceSha256": "b6590c1c5269e8e62a1ec72a8f04f21f123a77709854a8a66c436df25f3ff418"
 }

package/test/conformance/wg17-syntax-coverage.json

@@ -1,14 +1,14 @@
 {
   "source": "https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing",
-  "checkedOn": "2026-08-28",
+  "checkedOn": "2026-09-01",
   "upstream": {
     "firstId": 1,
-    "lastId": 374,
+    "lastId": 368,
     "deletedIds": [
       20,
       273
     ],
-    "activeCases": 372
+    "activeCases": 366
   },
   "evidence": [
     {

package/test/run-regression.mjs

@@ -5387,11 +5387,12 @@ ${profile}`;
         assertEqual(report.total.positive + report.total.errors + report.total.warnings + report.total.proofs, report.total.total, 'conformance total');
         assertEqual(report.rows.some((row) => row.category === 'legacy-numbered'), false, 'legacy-numbered category');
         const wg17 = report.executable.find((gate) => gate.name === 'WG17 syntax');
-        assertEqual(wg17?.total, 372, 'WG17 executable total');
-        assertEqual(wg17?.passed, 372, 'WG17 executable passed');
+        const wg17FixtureTotal = readWg17SyntaxFixture().cases.length;
+        assertEqual(wg17?.total, wg17FixtureTotal, 'WG17 executable total');
+        assertEqual(wg17?.passed, wg17FixtureTotal, 'WG17 executable passed');
         assertArrayEqual(wg17?.failures ?? [], [], 'WG17 executable failures');
         const text = formatConformanceReport(report);
-        assertIncludes(text, '| WG17 syntax | 372 | 372 | pass |', 'report');
+        assertIncludes(text, `| WG17 syntax | ${wg17FixtureTotal} | ${wg17FixtureTotal} | pass |`, 'report');
         assertIncludes(text, '| variables |', 'report');
         assertIncludes(text, '| Proofs |', 'report');
         assertIncludes(text, '| **Total** |', 'report');
@@ -7251,6 +7252,54 @@ function whiteBoxCases() {
         }
       },
     },
+    {
+      name: 'normal integer syntax accepts WG17 digit separators (issue #89)',
+      run: () => {
+        const values = parseGoalText(`values(
+          1_000,
+          0b1010_0101,
+          0o7_ 7,
+          0xCA_/* digit group */FE,
+          -9_% line group
+          223
+        )`).args;
+        assertEqual(values.map((value) => value.name).join(','), '1000,165,63,51966,-9223',
+          'decimal and radix separator values');
+        const program = Program.parse('decimal(1_000).\nhexadecimal(0xCA_FE).\n');
+        assertEqual(program.findGroup('decimal', 1)?.clauses[0].head.args[0].name, '1000',
+          'program decimal literal');
+        assertEqual(program.findGroup('hexadecimal', 1)?.clauses[0].head.args[0].name, '51966',
+          'program radix literal');
+        assertEqual(parseNumberTokenText('1_ /* group */ 000').name, '1000',
+          'number-token conversion with layout');
+        assertEqual(
+          run('', { goal: 'number_chars(N,"1_000")' }).stdout,
+          'number_chars(1000, "1_000").\n',
+          'normal number_chars input',
+        );
+        assertEqual(
+          run('', { goal: 'read_term(N, [])', ioOptions: { input: '1_ /* group */ 000. ' } }).stdout,
+          'read_term(1000, []).\n',
+          'stream term input',
+        );
+
+        for (const source of ['1__000', '1_', '1_a', '0b1_2', '1_1.25', '1.2_5', '1.0e1_0']) {
+          let threw = false;
+          try { parseGoalText(`p(${source})`); } catch (_) { threw = true; }
+          assertEqual(threw, true, `malformed or non-integer separator rejected: ${source}`);
+        }
+
+        for (const source of ['1_000', '0b1010_0101', '0o7_7', '0xCA_FE']) {
+          let threw = false;
+          try { parseGoalText(`p(${source})`, { isoStrict: true }); } catch (_) { threw = true; }
+          assertEqual(threw, true, `strict syntax rejects ${source}`);
+        }
+        let strictConversion = null;
+        try { run('', { isoStrict: true, goal: 'number_chars(N,"1_000")' }); }
+        catch (error) { strictConversion = error; }
+        assertEqual(strictConversion?.formal, 'syntax_error(number)', 'strict number_chars rejection');
+      },
+    },
     {
       name: 'double_quotes(true) remains effective with ignore_ops(true) in either option order (issue #88 follow-up)',
       run: () => {
@@ -8342,6 +8391,7 @@ function documentedConformanceMetricIssues() {
   const report = buildConformanceReport();
   const iso = report.rows.find((row) => row.category === 'iso')?.total;
   const total = report.total.total;
+  const wg17 = report.executable.find((gate) => gate.name === 'WG17 syntax')?.total;
   const checks = [
     {
       file: path.join(packageRoot, 'the-art-of-eyeprolog.md'),
@@ -8371,6 +8421,21 @@ function documentedConformanceMetricIssues() {
       }
     }
   }
+  for (const file of [
+    path.join(packageRoot, 'test', 'conformance', 'README.md'),
+    path.join(packageRoot, 'test', 'conformance', 'ISO-COMPLIANCE.md'),
+  ]) {
+    const relative = path.relative(packageRoot, file);
+    const text = fs.readFileSync(file, 'utf8');
+    const claims = [
+      ...[...text.matchAll(/\b(\d+)-case[^\n|]*WG17/g)].map((match) => Number(match[1])),
+      ...[...text.matchAll(/WG17[^\n|]*?\b(\d+) executable/g)].map((match) => Number(match[1])),
+    ];
+    if (claims.length === 0) issues.push(`${relative}: WG17 total not found`);
+    for (const claim of claims) {
+      if (claim !== wg17) issues.push(`${relative}: WG17 count ${claim} != ${wg17}`);
+    }
+  }
   return issues.sort();
 }
 

package/the-art-of-eyeprolog.md

@@ -465,6 +465,11 @@ for `[a,b|Tail]`; with `double_quotes(codes)`, it denotes `[97,98|Tail]`. The
 splice is not available when `double_quotes(atom)` is active, and
 `--iso-strict` rejects it as an implementation-specific syntax extension.
 
+Normal-mode integer constants may use one underscore between adjacent digits,
+as in `1_000` or `0xCA_FE`. Layout, including comments and newlines, may follow
+the underscore before the next digit. Separators do not apply to floating-point
+fractions or exponents, and `--iso-strict` rejects them.
+
 Plain atom constants begin with a lowercase ASCII letter. Variables begin with
 an uppercase letter or underscore. The bare `_` is anonymous and every
 occurrence is fresh. `_Name` is a named variable; repeated occurrences refer to
@@ -5648,8 +5653,10 @@ lowercase ASCII letter. Variables begin with uppercase or underscore. The bare
 `_` is fresh each time. Single quotes delimit quoted atoms; double quotes use
 ISO double-quoted-list notation. Integers, decimals, scientific notation,
 binary/octal/hexadecimal integers, and character-code constants are accepted.
-Normal mode additionally accepts the Trealla-compatible `"text"||Tail`
-right-splice for double-quoted `chars`/`codes` lists; strict ISO mode does not.
+Normal mode additionally accepts digit-separated integer constants such as
+`1_000` and `0xCA_FE`, with optional layout after the underscore, and the
+Trealla-compatible `"text"||Tail` right-splice for double-quoted `chars`/`codes`
+lists; strict ISO mode accepts neither syntax extension.
 
 The processor character set is shared by normal and `--iso-strict` modes because
 Part 1 makes it implementation defined rather than an extension boundary.
@@ -6190,7 +6197,7 @@ quoted_atom("ab").           % quoted_atom(ab)
 - **`sub_atom(+Atom,?Before,?Length,?After,?SubAtom)`** — Enumerates substrings and their Unicode-code-point offsets. Supplied counts must be nonnegative integers.
 - **`atom_chars(?Atom,?Chars)`, `atom_codes(?Atom,?Codes)`** — Convert between an atom and a proper list of one-character atoms or character codes. Both profiles use EyeProlog's Unicode scalar PCS/codes; surrogates and values above U+10FFFF are rejected. At least one side must be instantiated.
 - **`char_code(?Character,?Code)`** — Converts one character atom and its collating/code value. Both profiles accept Unicode scalar codes and reject surrogates/out-of-range values.
-- **`number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)`** — Convert finite numbers to canonical text or parse a proper character/code list using ISO number and negative-number syntax, including radix integers, character-code constants, and leading layout. The input is not parsed as a general term: grouping such as `(0)` is a syntax error. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*.
+- **`number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)`** — Convert finite numbers to canonical text or parse a proper character/code list using number and negative-number syntax, including radix integers, character-code constants, and leading layout. Normal mode also accepts digit separators in integer input; strict mode retains the ISO syntax. The input is not parsed as a general term: grouping such as `(0)` is a syntax error. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*.
 
 Conversions accept partial output lists when the atomic input is known, but
 constructing an atom or number requires a complete proper list with no unbound

package/tools/upgrade-wg17.mjs

@@ -11,6 +11,11 @@ const syntaxSource = 'https://www.complang.tuwien.ac.at/ulrich/iso-prolog/confor
 const syntaxFixturePath = path.join(packageRoot, 'test', 'conformance', 'wg17-syntax-cases.json');
 const syntaxCoveragePath = path.join(packageRoot, 'test', 'conformance', 'wg17-syntax-coverage.json');
 const syntaxStatusPath = path.join(packageRoot, 'test', 'conformance', 'WG17-SYNTAX-STATUS.md');
+const conformanceReportPath = path.join(packageRoot, 'conformance-report.md');
+const countDocumentationPaths = [
+  path.join(packageRoot, 'test', 'conformance', 'README.md'),
+  path.join(packageRoot, 'test', 'conformance', 'ISO-COMPLIANCE.md'),
+];
 
 const namedEntities = new Map([
   ['amp', '&'], ['lt', '<'], ['gt', '>'], ['quot', '"'], ['apos', "'"],
@@ -318,6 +323,20 @@ function formatIdList(ids) {
   return ids.length === 0 ? 'none' : ids.map((id) => `#${id}`).join(', ');
 }
 
+function updateDocumentedInventoryCount(previousCount, nextCount) {
+  if (previousCount === nextCount) return;
+  for (const filename of countDocumentationPaths) {
+    const original = fs.readFileSync(filename, 'utf8');
+    const updated = original
+      .replaceAll(`${previousCount}-case`, `${nextCount}-case`)
+      .replaceAll(`WG17 matrix has ${previousCount} executable`, `WG17 matrix has ${nextCount} executable`);
+    if (updated === original) {
+      throw new Error(`WG17 inventory count was not found in ${path.relative(packageRoot, filename)}`);
+    }
+    fs.writeFileSync(filename, updated);
+  }
+}
+
 async function readSource(source) {
   if (/^https?:\/\//i.test(source)) {
     const response = await fetch(source, {
@@ -415,6 +434,13 @@ export async function upgradeWg17({ check = false, source = syntaxSource } = {})
   // Generate status after the fixture/manifest are synchronized.
   const { renderWg17SyntaxStatus } = await import('./report-wg17-syntax-coverage.mjs');
   fs.writeFileSync(syntaxStatusPath, renderWg17SyntaxStatus());
+  updateDocumentedInventoryCount(previous.cases.length, fixture.cases.length);
+
+  // The public report executes the refreshed fixture, so keep its measured row
+  // synchronized as part of the same explicit upgrade operation.
+  const { buildConformanceReport, formatConformanceReport } = await import('../test/run-conformance-report.mjs');
+  const conformanceReport = buildConformanceReport();
+  fs.writeFileSync(conformanceReportPath, formatConformanceReport(conformanceReport));
 
   const upstreamAssertions = fixture.cases
     .filter((item) => item.outcome == null)