eyeprolog 1.3.41 → 1.3.43

package/src/parser.js

@@ -2,6 +2,7 @@
 // It preserves the compact Prolog-like syntax while producing Term objects for the solver.
 import { ATOM, COMPOUND, atom, compound, cons, emptyList, numberTerm, variable } from './term.js';
 import { continuesGraphicToken, isTerminatingFullStop } from './syntax-scan.js';
+import { CharacterRepresentationError, isStrictIsoPcsCodePoint } from './iso-character.js';
 
 
 export class NumberRepresentationError extends Error {
@@ -33,7 +34,10 @@ const TOK = {
 };
 
 function isWhitespaceCode(code) {
-  return code === 32 || code === 9 || code === 10 || code === 13 || code === 12 || code === 11;
+  // EyeProlog classifies ASCII C0 controls and DEL as layout characters. In
+  // strict mode these are the implementation-defined extended-layout members
+  // of the ASCII processor character set.
+  return (code >= 0 && code <= 32) || code === 127;
 }
 
 function isDigitCode(code) {
@@ -207,7 +211,11 @@ class Parser {
     this.strictIso = options.isoStrict === true;
     this.parserFlagState = options.parserFlagState ?? {
       doubleQuotes: options.doubleQuotes ?? 'chars',
+      charConversion: 'on',
+      charConversions: new Map(),
     };
+    this.parserFlagState.charConversion ??= 'on';
+    this.parserFlagState.charConversions ??= new Map();
     if (!['chars', 'codes', 'atom'].includes(this.parserFlagState.doubleQuotes)) {
       throw new Error(`invalid double_quotes parser flag: ${this.parserFlagState.doubleQuotes}`);
     }
@@ -223,6 +231,30 @@ class Parser {
     this.previousToken = null;
     this.token = this.nextToken();
   }
+  convertCharacter(character) {
+    if (this.parserFlagState.charConversion !== 'on' || !character) return character;
+    return this.parserFlagState.charConversions.get(character) ?? character;
+  }
+  rawPeek(offset = 0) {
+    const ch = this.source[this.pos + offset] ?? '';
+    if (this.strictIso && ch && !isStrictIsoPcsCodePoint(ch.charCodeAt(0))) {
+      throw new CharacterRepresentationError();
+    }
+    return ch;
+  }
+  rawTake() {
+    const ch = this.rawPeek();
+    if (ch) {
+      this.pos++;
+      if (ch === '\n') this.line++;
+    }
+    return ch;
+  }
+  convertedSlice(start, end) {
+    let out = '';
+    for (const ch of this.source.slice(start, end)) out += this.convertCharacter(ch);
+    return out;
+  }
   terminatingFullStop(index = this.pos) {
     // read/1 tries each possible full stop in turn.  While parsing a later
     // candidate, a preceding dot after a graphic character belongs to that
@@ -231,12 +263,12 @@ class Parser {
     // designated read-term candidate.
     if (this.readTermEnd != null) {
       if (index === this.readTermEnd) return true;
-      if (index < this.readTermEnd && continuesGraphicToken(this.source, index)) {
-        const next = this.source[index + 1] ?? '';
+      if (index < this.readTermEnd && continuesGraphicToken(this.source, index, (ch) => this.convertCharacter(ch))) {
+        const next = this.convertCharacter(this.source[index + 1] ?? '');
         if (next === '%' || /^[\u0009-\u000d\u0020]$/.test(next)) return false;
       }
     }
-    return isTerminatingFullStop(this.source, index);
+    return isTerminatingFullStop(this.source, index, (ch) => this.convertCharacter(ch));
   }
   defineOperator(priority, specifier, name) {
     defineParserOperator(this, priority, specifier, name);
@@ -273,12 +305,30 @@ class Parser {
     for (const name of names) this.defineOperator(priority, specifierTerm.name, name);
     return true;
   }
-  applyParserFlagDirective(directive) {
-    if (directive.type !== 'compound' || directive.name !== 'set_prolog_flag' || directive.arity !== 2) return;
-    const [flag, value] = directive.args;
-    if (flag.type === 'atom' && flag.name === 'double_quotes' &&
-        value.type === 'atom' && ['chars', 'codes', 'atom'].includes(value.name)) {
-      this.parserFlagState.doubleQuotes = value.name;
+  applyParserFlagDirective(directive, line = this.line) {
+    if (directive.type !== 'compound' || directive.arity !== 2) return;
+    if (directive.name === 'set_prolog_flag') {
+      const [flag, value] = directive.args;
+      if (flag.type === 'atom' && flag.name === 'double_quotes' &&
+          value.type === 'atom' && ['chars', 'codes', 'atom'].includes(value.name)) {
+        this.parserFlagState.doubleQuotes = value.name;
+      } else if (flag.type === 'atom' && flag.name === 'char_conversion' &&
+                 value.type === 'atom' && ['on', 'off'].includes(value.name)) {
+        this.parserFlagState.charConversion = value.name;
+      }
+      return;
+    }
+    if (directive.name === 'char_conversion') {
+      const [input, output] = directive.args;
+      const validCharacter = (term) => term.type === 'atom' && Array.from(term.name).length === 1;
+      if (input.type === 'var' || output.type === 'var') {
+        throw new Error(`parse line ${line}: char_conversion/2 arguments must be instantiated characters`);
+      }
+      if (!validCharacter(input) || !validCharacter(output)) {
+        throw new Error(`parse line ${line}: char_conversion/2 requires one-character atoms`);
+      }
+      if (input.name === output.name) this.parserFlagState.charConversions.delete(input.name);
+      else this.parserFlagState.charConversions.set(input.name, output.name);
     }
   }
   applyImportedLibraryOperators(directive) {
@@ -301,46 +351,45 @@ class Parser {
     return null;
   }
   peek(offset = 0) {
-    return this.source[this.pos + offset] ?? '';
+    return this.convertCharacter(this.rawPeek(offset));
   }
   take() {
-    const ch = this.peek();
-    if (ch) {
+    const raw = this.rawPeek();
+    const ch = this.convertCharacter(raw);
+    if (raw) {
       this.pos++;
-      if (ch === '\n') this.line++;
+      if (raw === '\n') this.line++;
     }
     return ch;
   }
   skipWhitespaceAndComments() {
-    const source = this.source;
-    const len = source.length;
     while (true) {
-      while (this.pos < len) {
-        const code = source.charCodeAt(this.pos);
-        if (!isWhitespaceCode(code)) break;
-        if (code === 10) this.line++;
-        this.pos++;
+      while (this.rawPeek()) {
+        const ch = this.peek();
+        if (!isWhitespaceCode(ch.charCodeAt(0))) break;
+        this.take();
       }
-      if (source.charCodeAt(this.pos) === 37) { // % line comment
-        while (this.pos < len && source.charCodeAt(this.pos) !== 10) this.pos++;
+      if (this.peek() === '%') {
+        while (this.rawPeek() && this.peek() !== '\n') this.take();
         continue;
       }
-      if (source[this.pos] === '/' && source[this.pos + 1] === '*') {
+      if (this.peek() === '/' && this.peek(1) === '*') {
         const line = this.line;
-        this.pos += 2;
-        while (this.pos < len && !(source[this.pos] === '*' && source[this.pos + 1] === '/')) {
-          if (source.charCodeAt(this.pos) === 10) this.line++;
-          this.pos++;
-        }
-        if (this.pos >= len) throw new Error(`parse line ${line}: unterminated block comment`);
-        this.pos += 2;
+        this.take();
+        this.take();
+        while (this.rawPeek() && !(this.peek() === '*' && this.peek(1) === '/')) this.take();
+        if (!this.rawPeek()) throw new Error(`parse line ${line}: unterminated block comment`);
+        this.take();
+        this.take();
         continue;
       }
       break;
     }
   }
   readEscape(line, options = {}) {
-    const escaped = this.take();
+    const takeChar = () => options.raw ? this.rawTake() : this.take();
+    const peekChar = () => options.raw ? this.rawPeek() : this.peek();
+    const escaped = takeChar();
     if (!escaped) throw new Error(`parse line ${line}: unterminated escape sequence`);
 
     // ISO 6.4.2 permits a continuation escape only inside quoted tokens: a
@@ -350,9 +399,9 @@ class Parser {
       if (options.allowContinuation !== false) return '';
       throw new Error(`parse line ${line}: bad escape sequence`);
     }
-    if (escaped === '\r' && this.peek() === '\n') {
+    if (escaped === '\r' && peekChar() === '\n') {
       if (options.allowContinuation !== false) {
-        this.take();
+        takeChar();
         return '';
       }
       throw new Error(`parse line ${line}: bad escape sequence`);
@@ -363,22 +412,24 @@ class Parser {
 
     if (escaped === 'x') {
       let digits = '';
-      while (/^[0-9A-Fa-f]$/.test(this.peek())) digits += this.take();
-      if (!digits || this.take() !== '\\') throw new Error(`parse line ${line}: bad hexadecimal escape`);
+      while (/^[0-9A-Fa-f]$/.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)) {
         throw new Error(`parse line ${line}: character escape out of range`);
       }
+      if (this.strictIso && !isStrictIsoPcsCodePoint(code)) throw new CharacterRepresentationError();
       return String.fromCodePoint(code);
     }
     if (/^[0-7]$/.test(escaped)) {
       let digits = escaped;
-      while (/^[0-7]$/.test(this.peek())) digits += this.take();
-      if (this.take() !== '\\') throw new Error(`parse line ${line}: bad octal escape`);
+      while (/^[0-7]$/.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)) {
         throw new Error(`parse line ${line}: character escape out of range`);
       }
+      if (this.strictIso && !isStrictIsoPcsCodePoint(code)) throw new CharacterRepresentationError();
       return String.fromCodePoint(code);
     }
     // A backslash followed by a decimal digit is numeric-escape syntax, but
@@ -411,7 +462,7 @@ class Parser {
       this.take();
       while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
              !this.terminatingFullStop()) this.take();
-      return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
+      return { type: TOK.ATOM, text: this.convertedSlice(start, this.pos), line };
     }
     if (ch === '!') {
       this.take();
@@ -442,20 +493,29 @@ class Parser {
     }
 
     if (ch === '"' || ch === "'") {
+      // Whether an input character is quoted is determined from the target
+      // source before character conversion (ISO 8.14.1 note 1). A literal
+      // quote therefore protects its contents from Convc; if a conversion
+      // itself produces a quote token, the following raw characters remain
+      // subject to conversion while that resulting token is parsed.
+      const rawOpening = this.rawPeek();
       const quote = this.take();
+      const literalQuote = rawOpening === quote;
+      const peekQuoted = () => literalQuote ? this.rawPeek() : this.peek();
+      const takeQuoted = () => literalQuote ? this.rawTake() : this.take();
       let text = '';
       while (true) {
-        if (!this.peek()) throw new Error(`parse line ${line}: unterminated quoted term`);
-        let value = this.take();
+        if (!peekQuoted()) throw new Error(`parse line ${line}: unterminated quoted term`);
+        let value = takeQuoted();
         if (value === quote) {
-          if (this.peek() === quote) {
-            this.take();
+          if (peekQuoted() === quote) {
+            takeQuoted();
             value = quote;
           } else {
             break;
           }
-        } else if (value === '\\' && this.peek()) {
-          value = this.readEscape(line);
+        } else if (value === '\\' && peekQuoted()) {
+          value = this.readEscape(line, { raw: literalQuote });
         } else if (value !== ' ' && isWhitespaceCode(value.charCodeAt(0))) {
           // ISO 6.4.2.1 allows an ordinary space in a quoted character, but
           // not literal layout characters such as tab or newline. Newlines
@@ -489,17 +549,20 @@ class Parser {
         (this.peek(2) !== "'" || this.peek(3) === "'") &&
         !(this.peek(2) === '\\' && this.peek(3) === '\n');
       if (startsQuotedCharacter) {
+        const rawQuotedCharacter = this.rawPeek() === '0' && this.rawPeek(1) === "'";
         this.take();
         this.take();
-        let value = this.take();
+        const takeCharacter = () => rawQuotedCharacter ? this.rawTake() : this.take();
+        const peekCharacter = () => rawQuotedCharacter ? this.rawPeek() : this.peek();
+        let value = takeCharacter();
         if (value) {
           const firstCode = value.charCodeAt(0);
           if (firstCode >= 0xd800 && firstCode <= 0xdbff) {
-            const secondCode = this.peek().charCodeAt(0);
+            const secondCode = peekCharacter().charCodeAt(0);
             if (secondCode < 0xdc00 || secondCode > 0xdfff) {
               throw new Error(`parse line ${line}: bad character code constant`);
             }
-            value += this.take();
+            value += takeCharacter();
           } else if (firstCode >= 0xdc00 && firstCode <= 0xdfff) {
             throw new Error(`parse line ${line}: bad character code constant`);
           }
@@ -512,10 +575,10 @@ class Parser {
           // apostrophe is doubled just as it is inside a quoted atom. Thus
           // 0''' is one numeric token denoting character code 39, while the
           // undoubled 0'' is not a complete single quoted character.
-          if (this.peek() !== "'") throw new Error(`parse line ${line}: bad character code constant`);
-          this.take();
+          if (peekCharacter() !== "'") throw new Error(`parse line ${line}: bad character code constant`);
+          takeCharacter();
         } else if (value === '\\') {
-          value = this.readEscape(line, { allowContinuation: false });
+          value = this.readEscape(line, { allowContinuation: false, raw: rawQuotedCharacter });
         }
         const code = value.codePointAt(0);
         return { type: TOK.NUMBER, text: String(negative ? -code : code), line };
@@ -550,14 +613,14 @@ class Parser {
       // followed by the name E9 and is not a valid term without an operator.
       if (hasFraction && (this.peek() === 'e' || this.peek() === 'E')) {
         let idx = this.pos + 1;
-        if (this.source[idx] === '+' || this.source[idx] === '-') idx++;
-        if (isDigitCode((this.source[idx] ?? '').charCodeAt(0))) {
+        if (['+', '-'].includes(this.convertCharacter(this.source[idx] ?? ''))) idx++;
+        if (isDigitCode(this.convertCharacter(this.source[idx] ?? '').charCodeAt(0))) {
           this.take();
           if (this.peek() === '+' || this.peek() === '-') this.take();
           while (isDigitCode(this.peek().charCodeAt(0))) this.take();
         }
       }
-      let text = this.source.slice(start, this.pos);
+      let text = this.convertedSlice(start, this.pos);
       if (!hasFraction) text = BigInt(text).toString();
       else text = finiteFloatTokenText(text);
       return { type: TOK.NUMBER, text, line };
@@ -567,7 +630,7 @@ class Parser {
       const start = this.pos;
       this.take();
       while (isNameContinueCode(this.peek().charCodeAt(0))) this.take();
-      const text = this.source.slice(start, this.pos);
+      const text = this.convertedSlice(start, this.pos);
       return { type: TOK.VAR, text, line };
     }
 
@@ -575,7 +638,7 @@ class Parser {
       const start = this.pos;
       this.take();
       while (isNameContinueCode(this.peek().charCodeAt(0))) this.take();
-      return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
+      return { type: TOK.ATOM, text: this.convertedSlice(start, this.pos), line };
     }
 
     if (isGraphicAtomCode(ch.charCodeAt(0))) {
@@ -583,7 +646,7 @@ class Parser {
       this.take();
       while (isGraphicAtomCode(this.peek().charCodeAt(0)) &&
              !this.terminatingFullStop()) this.take();
-      return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
+      return { type: TOK.ATOM, text: this.convertedSlice(start, this.pos), line };
     }
 
     throw new Error(`parse line ${line}: bad character ${JSON.stringify(ch)}`);
@@ -934,7 +997,7 @@ class Parser {
           throw new Error(`parse line ${line}: bad term`);
         }
         this.expect(TOK.DOT, '.');
-        this.applyParserFlagDirective(directive);
+        this.applyParserFlagDirective(directive, line);
         this.applyImportedLibraryOperators(directive);
         this.advance();
         const clause = { head: compound(':-', [directive]), body: [] };
@@ -1080,12 +1143,16 @@ export function parseClauses(source, options = {}) {
   const ownsParserFlagState = options.parserFlagState == null;
   const initialDoubleQuotes = options.doubleQuotes ?? 'chars';
   const parserOptions = ownsParserFlagState
-    ? { ...options, parserFlagState: { doubleQuotes: initialDoubleQuotes } }
+    ? { ...options, parserFlagState: { doubleQuotes: initialDoubleQuotes, charConversion: 'on', charConversions: new Map() } }
     : options;
   if (options.sourceMetadata === false && options.readTermEnd == null) {
     const clauses = parseClausesFastNoSource(source, null, null, parserOptions);
     if (clauses) return clauses;
-    if (ownsParserFlagState) parserOptions.parserFlagState.doubleQuotes = initialDoubleQuotes;
+    if (ownsParserFlagState) {
+      parserOptions.parserFlagState.doubleQuotes = initialDoubleQuotes;
+      parserOptions.parserFlagState.charConversion = 'on';
+      parserOptions.parserFlagState.charConversions.clear();
+    }
   }
   return new Parser(source, parserOptions).parseProgram();
 }
@@ -1381,11 +1448,19 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     return head && bodyGoal ? { head, body: [bodyGoal] } : null;
   };
 
+  const preparationConversionActive = () =>
+    options.parserFlagState?.charConversion === 'on' &&
+    (options.parserFlagState?.charConversions?.size ?? 0) > 0;
+
   const flush = () => {
     const text = chunk.trim();
     chunk = '';
     if (!text) return true;
-    const simple = parseSimple(text);
+    // Once a preparation-time char_conversion/2 mapping is active, every
+    // subsequent source character must pass through the full tokenizer. The
+    // compact parser deliberately operates on raw source ranges, so using it
+    // here would silently bypass Convc for otherwise simple clauses.
+    const simple = preparationConversionActive() ? null : parseSimple(text);
     if (simple) {
       accept(simple);
       return true;
@@ -1408,7 +1483,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     if (contentEnd > contentStart && source.charCodeAt(contentEnd - 1) === 13) contentEnd--;
     [contentStart, contentEnd] = trimRange(source, contentStart, contentEnd);
     if (contentStart < contentEnd && source.charCodeAt(contentStart) !== 37) {
-      if (!chunk && source.charCodeAt(contentEnd - 1) === 46) {
+      if (!chunk && source.charCodeAt(contentEnd - 1) === 46 && !preparationConversionActive()) {
         if (emitFastBinaryRange(source, contentStart, contentEnd)) {
           // The program builder accepted a compact binary clause directly.
         } else {

package/src/program.js

@@ -650,7 +650,7 @@ export function autoloadProgramGoals(program, inputs, options = {}) {
     false,
     { isoStrict: program.strictIso },
   );
-  const parserFlagState = { doubleQuotes: program.doubleQuotes ?? options.doubleQuotes ?? 'chars' };
+  const parserFlagState = { doubleQuotes: program.doubleQuotes ?? options.doubleQuotes ?? 'chars', charConversion: 'on', charConversions: new Map() };
   const goals = parseInteropGoalInputs(inputs, {
     ...options,
     isoStrict: program.strictIso,
@@ -684,7 +684,7 @@ function loadSourcesIntoBuilder(builder, sources, options, fast) {
   const ensured = new Set();
   const loadedModules = new Set();
   const operatorState = createParserOperatorState([], true, { isoStrict: options.isoStrict === true });
-  const parserFlagState = { doubleQuotes: options.doubleQuotes ?? 'chars' };
+  const parserFlagState = { doubleQuotes: options.doubleQuotes ?? 'chars', charConversion: 'on', charConversions: new Map() };
   const prepared = sources.map((source) => ({
     source,
     options: { ...sourceOptionsFor(source, options), operatorState, parserFlagState },

package/src/solver.js

@@ -955,8 +955,8 @@ function defaultPrologFlags(unknown = 'error', strictIso = false) {
     ['integer_rounding_function', { value: compound('toward_zero', []), allowed: ['toward_zero'], changeable: false }],
     ['char_conversion', { value: compound('on', []), allowed: ['on', 'off'], changeable: true }],
     ['debug', { value: compound('off', []), allowed: ['on', 'off'], changeable: true }],
-    ['max_integer', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
-    ['min_integer', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
+    ['max_integer', { value: null, allowed: ['unbounded'], changeable: false }],
+    ['min_integer', { value: null, allowed: ['unbounded'], changeable: false }],
     ['max_arity', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
     ['unknown', { value: compound(unknown, []), allowed: ['error', 'fail', 'warning'], changeable: true }],
     ['double_quotes', { value: compound('chars', []), allowed: ['chars', 'codes', 'atom'], changeable: true }],

package/src/standard-library.js

@@ -1,4 +1,4 @@
-// ISO/IEC 13211-2 module sources shipped with EyeProlog.
+// Prolog library modules shipped with EyeProlog and loaded through its documented module compatibility surface.
 // The sources are registered here so library(Name) works in Node and browsers.
 // Modules are loaded on demand by explicit use_module/1-2 or by the conservative
 // source-level interop autoloader declared below.

package/src/syntax-scan.js

@@ -46,7 +46,7 @@ export function isTerminatingFullStop(source, index, convert = null) {
   // token character accepted by continuesGraphicToken().
   if (continuesGraphicToken(source, index, convert)) return false;
   if (next === '' || next === '%' || next === '\n' || next === '\r') return true;
-  if (/^[\u0009\u000b\u000c\u0020]$/.test(next)) return true;
+  if (/^[\u0000-\u0020\u007f]$/.test(next)) return true;
   return false;
 }
 

package/test/conformance/ISO-COMPLIANCE.md

@@ -30,15 +30,15 @@ error-ordering alternative to an individual executable assertion.
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete vendored WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, and writer/read-back regressions. |
-| 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates. |
-| 7.4 — Prolog text and directives | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Cross-text `multifile/1` and ordering constraints require explicit shall-by-shall audit. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete vendored WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, writer/read-back regressions, and strict ASCII PCS/collation boundary tests. The implementation-defined 6.5/6.6 character-model decisions are now closed; wider shall-by-shall lexical mapping remains open. |
+| 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates, plus strict checks for the required `variable < float < integer < atom < compound` type order and PCS-based atom collation. |
+| 7.4 — Prolog text and directives | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Preparation-time `char_conversion/2` now affects later unquoted source text and respects `char_conversion=off`. Cross-text `multifile/1` and ordering constraints still require explicit shall-by-shall audit. |
 | 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access. Public/private and multi-text requirements still need complete mapping. |
 | 7.7 — execution and backtracking | audit | Control/search suites. Strict mode disables EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts so core execution uses ordinary clause selection/backtracking. |
 | 7.8 — control constructs and exceptions | audit | call, cut, conjunction, disjunction (including failed branches after callee-local cuts), if-then, catch/throw, renamed-copy tests. |
 | 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Exceptional-value/error-precedence matrix remains to be exhaustively enumerated. |
 | 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, Corrigendum 3 writer cases. Full option cross-product remains open. |
-| 7.11 — flags | audit | Required Part 1 flags implemented. Normal and strict modes use the ISO `unknown=error` default; strict mode excludes the EyeProlog `occurs_check` extension. |
+| 7.11 — flags | audit | Required Part 1 flags implemented. Normal and strict modes use the ISO `unknown=error` default; strict mode excludes the EyeProlog `occurs_check` extension. With `bounded=false`, `max_integer` and `min_integer` correctly have no current value. |
 | 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax families and focused error cases. Complete prescribed-error ordering remains open. |
 | 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md; Corrigendum 2 additions (`subsumes_term/2`, `term_variables/2`, `call/2..8`, `false/0`) are in the strict registry. Mode/error matrix is not yet one-row-per-standard-row. |
 | Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Host floating-point representation choices remain documented implementation-defined behavior. |
@@ -46,6 +46,29 @@ error-ordering alternative to an individual executable assertion.
 | Corrigendum 2 | covered | Added predicates/functors, catch corrections, bar/operator and uninstantiation corrections have dedicated cases. |
 | Corrigendum 3 | covered | Writer options, `variable_names/1`, canonical list output and negative-power corrections have dedicated cases. |
 
+## Issue #65 conformance corrections
+
+The issue #65 audit against the licensed Part 1 text and Corrigenda closed two
+concrete mismatches without changing the remaining audit rows into blanket
+conformance claims:
+
+- `bounded=false` no longer exposes implementation-specific `unbounded` values
+  for `max_integer` or `min_integer`; the corresponding
+  `current_prolog_flag/2` queries fail as specified by 7.11.1.1;
+- preparation-time `char_conversion/2` now converts later unquoted source text
+  when the `char_conversion` flag is `on`, leaves quoted characters unchanged,
+  and feeds the same mapping into execution-time term input.
+
+A follow-on audit closes the processor-character-set/collation choices rather
+than leaving them implicit. `--iso-strict` now selects the 128-character ASCII
+PCS U+0000..U+007F, classifies C0 controls and DEL as extended layout
+characters, and uses the code point itself as each collating-sequence integer.
+Characters/codes outside that PCS raise representation errors in strict
+parsing, term input, character conversion, and character-code predicates. The
+normal profile retains Unicode scalar character data as an explicit extension.
+The complete WG17 syntax matrix remains green under this narrower strict
+boundary.
+
 ## Strict-core boundary
 
 `isoStrict: true` is intentionally a **Part 1 + Corrigenda 1-3** mode. It does
@@ -64,9 +87,11 @@ remain ordinary operator syntax in strict core mode. A conforming `op/3`
 directive may still add an infix `?-` definition; strict mode reads that as an
 ordinary term rather than as a quad.
 
-Part 2 modules and Part 3 grammar rules remain supported and tested in the
+Module and DCG compatibility features remain supported and tested in the
 normal EyeProlog profile. They are tracked separately in ISO-MATRIX.md rather
-than being silently folded into the Part 1 strict-core claim.
+than being silently folded into the Part 1 strict-core claim. The project does
+not currently assert that this evidence closes every requirement of ISO/IEC
+13211-2:2000 or ISO/IEC TS 13211-3.
 
 ## Release gate
 

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

@@ -19,23 +19,23 @@ Status values are:
 - **defined** — the current behavior is implemented and stated here;
 - **not applicable** — the standard decision is conditional and the condition
   is false for EyeProlog's selected profile;
-- **audit gap** — the current code behavior is stated, but strict-mode
-  conformance still needs a correction or a narrower profile before this row
-  can support a full conformance claim.
+- **audit gap** — retained for any future implementation-defined choice whose
+  code/documentation boundary is still unresolved. Open *normative* shall-by-
+  shall work is tracked separately in `ISO-COMPLIANCE.md`.
 
 ## Explicit implementation-defined decisions
 
 | Clause | Decision completed by ISO 5.4 documentation | EyeProlog choice | Status / implementation evidence |
 | --- | --- | --- | --- |
 | 5.5.11 | Reserved atoms and the effect of instantiating a variable to one | EyeProlog reserves no Prolog atom under 5.5.11. Atoms with implementation-looking names remain ordinary terms unless a particular predicate interprets them. | **defined** — term representation and built-ins in `src/term.js`, `src/iso.js`. |
-| 6.5 | Processor character set (PCS) | The unquoted ISO lexical classes are the Part 1 ASCII characters implemented by `src/parser.js`. Quoted character data additionally accepts Unicode scalar values. | **audit gap** — the Unicode quoted-character extension is currently also accepted by `--iso-strict`; strict extension rejection still needs a narrower PCS rule or a documented conforming classification. |
-| 6.5 | Classification of additional/extended PCS characters | Non-ASCII scalar values are not accepted as unquoted small-letter, capital-letter, graphic, solo, layout, or meta characters; they are accepted only inside quoted character data. | **audit gap** — same strict-mode boundary as the preceding row. |
-| 6.6 | Collating-sequence integers | Character codes are Unicode scalar values. Atom comparison uses ECMAScript string lexicographic order; on the ISO ASCII repertoire this is code-point order and satisfies the required monotonic ranges. | **defined** — `src/term.js` (`compareTerms`), `src/iso.js` character-code predicates. |
-| 6.6 | Collating values of control escapes and extended characters | Control escapes and character-code predicates use Unicode scalar values. Atom ordering is ECMAScript string order; for non-BMP one-char atoms that order is based on UTF-16 code units rather than scalar values. | **audit gap** — the ISO ASCII repertoire is conforming, but the extended-character collating rule still needs one coherent documented integer/order mapping in strict mode. |
+| 6.5 | Processor character set (PCS) | In `--iso-strict`, PCS is the 128-character 7-bit ASCII set U+0000..U+007F. Normal mode additionally accepts Unicode scalar values in character data as an implementation-specific extension. | **defined** — `src/iso-character.js`, strict parser/character-I/O guards, and strict-core/WG17 coverage. |
+| 6.5 | Classification of additional/extended PCS characters | Printable ASCII uses the lexical classes specified by Part 1. ASCII C0 controls U+0000..U+001F and DEL U+007F are EyeProlog's extended **layout** characters; they may therefore separate tokens, while quoted control values are written/read through the ISO escape forms. No non-ASCII character belongs to strict PCS. | **defined** — `src/parser.js`, `src/syntax-scan.js`, `src/iso-character.js`. |
+| 6.6 | Collating-sequence integers | In strict mode each PCS character's collating-sequence integer is its ASCII/Unicode code point, 0..127. Atom comparison is lexicographic by the same code-unit values, which coincide with those integers throughout strict PCS and satisfy the required capital-letter, small-letter, and decimal-digit constraints. | **defined** — `src/iso-character.js`, `src/term.js` (`compareTerms`), `src/iso.js` character-code predicates. |
+| 6.6 | Collating values of control escapes and extended characters | Strict control/extended-layout characters use their ASCII code point as collating integer, so octal/hexadecimal escapes and character-code constants map to the same 0..127 PCS. Normal-mode Unicode character codes use Unicode scalar values; that broader ordering is outside the strict Part 1 profile. | **defined** — `src/iso-character.js`, parser escape handling, `char_code/2`, `atom_codes/2`, and WG17 escape cases. |
 | 7.1.2.2 | Mapping between a character code and bytes | Text file streams decode and encode UTF-8. Binary streams expose bytes 0..255 directly. | **defined** — `src/io.js`. |
-| 7.1.4.1 | Set `C` of characters represented by one-char atoms | Character predicates accept Unicode scalar values U+0000..U+10FFFF excluding surrogate code points. | **defined** — `src/iso.js` character-code validation. |
+| 7.1.4.1 | Set `C` of characters represented by one-char atoms | In strict mode `C` is exactly the ASCII PCS U+0000..U+007F. Normal mode extends character predicates to Unicode scalar values U+0000..U+10FFFF excluding surrogates. | **defined** — `src/iso-character.js`, `src/iso.js` character-code validation. |
 | 7.4.2.4 | Whether `op/3` directives affect other Prolog texts or execution | An `op/3` directive changes parsing of subsequent text loaded into the same `Program`; the resulting operator table is also used by execution-time term I/O. Separately created `Program` objects are independent. | **defined** — `src/parser.js`, `src/program.js`, `src/iso.js`. |
-| 7.4.2.5 | Whether directive-created `Convc` affects other text/execution | Directive mappings are copied into the solver's execution-time `charConversions` map. The source tokenizer itself does not currently apply `char_conversion/2` to later unquoted source characters. | **audit gap** — `src/program.js`, `src/solver.js`; source-preparation conversion remains to be aligned with 7.11.2.1. |
+| 7.4.2.5 | Whether directive-created `Convc` affects other text/execution | Yes. A `char_conversion/2` directive updates preparation-time conversion for later unquoted source characters and the recorded mapping initializes execution-time term input. Quoted characters are not converted; `char_conversion=off` disables following preparation-time conversion. | **defined** — `src/parser.js`, `src/program.js`, `src/solver.js`; strict-core regression coverage. |
 | 7.4.2.6 | Order of `initialization/1` goals | Initialization goals run once, in source/inclusion order, before requested goals; each must obtain a first solution. | **defined** — `Program.initializations`, `Solver.runInitializations()`. |
 | 7.4.2.7 | Ground term designating a Prolog text for `include/1` | A source designation is an atom interpreted as a file path; relative paths resolve from the including file's directory (or the current working directory for unanchored input). | **defined** — `src/program.js` (`readIncludedSource`). |
 | 7.4.2.8 | Ground term designating a Prolog text for `ensure_loaded/1` | Same atom/file-path designation as `include/1`. | **defined** — `src/program.js`. |
@@ -59,17 +59,17 @@ Status values are:
 | 7.10.2.13 | `eof_action(Action)` property when the stream uses its default action | Reports the same selected action: `error` for ordinary opened files and `reset` for the predefined standard streams. | **defined** — `streamProperties()` in `src/iso.js`, defaults in `src/io.js`. |
 | 7.10.2.11 | Whether `reposition(false)` streams may nevertheless be repositioned | No. `set_stream_position/2` raises a permission error unless the stream was created with `reposition(true)`. | **defined** — `src/iso.js`. |
 | 7.11.1.1 | Default `bounded` flag | `false`: EyeProlog's Prolog integer model uses arbitrary-precision `BigInt`, subject to host resources. | **defined** — `defaultPrologFlags()` in `src/solver.js`. |
-| 7.11.1.2 | Default `max_integer` when `bounded=true` | The bounded-profile default is not applicable because EyeProlog selects `bounded=false`. However, EyeProlog currently exposes the sentinel atom `unbounded` through `current_prolog_flag/2` instead of making the `max_integer` query fail as 7.11.1.1 prescribes for an unbounded processor. | **audit gap** — `src/solver.js`, `current_prolog_flag/2`. |
-| 7.11.1.3 | Default `min_integer` when `bounded=true` | The bounded-profile default is not applicable because EyeProlog selects `bounded=false`. However, EyeProlog currently exposes the sentinel atom `unbounded` through `current_prolog_flag/2` instead of making the `min_integer` query fail as 7.11.1.1 prescribes for an unbounded processor. | **audit gap** — `src/solver.js`, `current_prolog_flag/2`. |
+| 7.11.1.2 | Default `max_integer` when `bounded=true` | Not applicable because EyeProlog selects `bounded=false`; consequently `current_prolog_flag(max_integer, _)` fails. | **not applicable** — `src/solver.js`, `current_prolog_flag/2`; strict-core regression coverage. |
+| 7.11.1.3 | Default `min_integer` when `bounded=true` | Not applicable because EyeProlog selects `bounded=false`; consequently `current_prolog_flag(min_integer, _)` fails. | **not applicable** — `src/solver.js`, `current_prolog_flag/2`; strict-core regression coverage. |
 | 7.11.1.4 | Default `integer_rounding_function` flag | `toward_zero`; `//` uses truncation toward zero. `div` is provided separately with downward/floor division semantics. | **defined** — `src/solver.js`, `src/iso-arithmetic.js`. |
 | 9.1.3.1 | Integer division rounding function `rndI` | Truncation toward zero, matching the `integer_rounding_function=toward_zero` flag. | **defined** — BigInt division for `//` in `src/iso-arithmetic.js`. |
-| 7.11.2.1 | Whether preparation-time `Convc` affects execution-time `Convc` | Yes: mappings recorded by `char_conversion/2` directives initialize the solver map. Source-token conversion itself has the audit gap noted at 7.4.2.5. | **defined / audit note** — `src/solver.js`. |
+| 7.11.2.1 | Whether preparation-time `Convc` affects execution-time `Convc` | Yes: mappings created while Prolog text is prepared are retained and initialize the solver's execution-time conversion map. | **defined** — `src/parser.js`, `src/program.js`, `src/solver.js`. |
 | 7.11.2.2 | Effect when `debug=on` | The flag is accepted and stored; it does not change goal semantics or enable a debugger. | **defined** — `src/solver.js`; no semantic branch depends on `debug`. |
 | 7.11.2.3 | Default `max_arity` | `unbounded` in the Prolog model, subject to host memory and practical JavaScript array/index limits. | **defined** — `src/solver.js`; relevant guards report representation/resource errors. |
 | 7.11.2.5 | Default `double_quotes` | `chars`. | **defined** — `src/solver.js`, parser flag state. |
 | 7.12.1 | Second argument of `error/2` | The default context term is the atom `eyeprolog`. A few implementation-specific diagnostics may deliberately supply a more specific context term. | **defined** — `formalErrorTerm()` in `src/iso.js`. |
-| 7.12.2(f) | Implementation-defined representation limits | Character and character-code operations use Unicode scalar limits; arity/integer values are modeled as unbounded but may hit host/resource limits. Float input overflow uses the implementation-specific `max_float`/`min_float` representation names documented by the STC-oriented tests. | **defined** — parser/ISO numeric and character guards. |
-| 8.17.1 | Implementation-defined flag value ranges | Strict mode exposes only Part 1 core flags and their standard value sets. Normal mode additionally exposes EyeProlog's `occurs_check` flag; `max_integer`/`min_integer` use the `unbounded` sentinel described above. | **defined** — strict registry/flag filtering in `src/solver.js`. |
+| 7.12.2(f) | Implementation-defined representation limits | Strict character and character-code operations are limited to the selected ASCII PCS/collating integers 0..127. Normal mode extends characters to Unicode scalar values. Arity/integer values are modeled as unbounded but may hit host/resource limits. Float input overflow uses the implementation-specific `max_float`/`min_float` representation names documented by the STC-oriented tests. | **defined** — parser/ISO numeric and character guards. |
+| 8.17.1 | Implementation-defined flag value ranges | Strict mode exposes only Part 1 core flags and their standard value sets. Normal mode additionally exposes EyeProlog's `occurs_check` flag. With `bounded=false`, `max_integer` and `min_integer` have no current value and their `current_prolog_flag/2` queries fail. | **defined** — strict registry/flag filtering in `src/solver.js`. |
 | 8.17.3 | Other effects of `halt/0` | Terminates EyeProlog execution and returns host/process status `0`; it produces no Prolog solution. | **defined** — `HaltSignal`, `haltBuiltin()`, CLI/runner handling. |
 | 8.17.4 | Meaning/effects of `halt(Status)` | Integer `Status` is converted to the host process/runner halt code; it produces no Prolog solution. | **defined** — `haltBuiltin()`, `src/execute.js`, `src/cli.js`. |
 | 9.1.4.1 | Floating-point rounding function `rndF` | Floating values and operations use ECMAScript `Number` (IEEE-754 binary64) and the host's specified binary64 arithmetic/conversions. | **defined** — `src/iso-arithmetic.js`, `src/number-value.js`. |
@@ -105,7 +105,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, and embedded quad syntax | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax is rejected. Unicode quoted-character handling is the open PCS audit item above. |
+| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, embedded quad syntax, and normal-mode Unicode character data | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax is rejected; strict character syntax/data is limited to the documented ASCII PCS. |
 | 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 | No additional runtime Prolog term type is exposed by the core solver | Only variable, integer, float, atom, and compound term ordering participates in strict mode. |
@@ -118,9 +118,10 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.11 Reserved atoms | None | None. |
 | Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Strict core accepts the standard option names implemented for Part 1; invalid options follow Corrigendum 3 validation. |
 
-Part 2 and Part 3 are separately standardized profiles when EyeProlog is run in
-its normal mode; the table above describes them as extensions only relative to
-the Part 1 strict-core boundary.
+Normal mode provides documented module and DCG compatibility profiles whose
+features overlap standardized Part 2 and Part 3 facilities. They are extensions
+relative to the Part 1 strict-core boundary and are tested separately; this
+ledger does not assert complete Part 2 or Part 3 conformance.
 
 ## Important implementation-dependent behavior (not the 5.4 mandatory table)