eyeprolog 1.3.41 → 1.3.42

package/README.md

@@ -221,10 +221,18 @@ newly upgraded cases run directly against the upstream Codex expectation.
 EyeProlog does not yet claim independent certification or closure of every
 normative Part 1 requirement.
 
-## ISO modules and definite clause grammars
+## Module and definite clause grammar compatibility profiles
 
-EyeProlog implements ISO/IEC 13211-2 modules and the grammar rules and
-`phrase/2-3` predicates of ISO/IEC TS 13211-3:2025. For example:
+Normal EyeProlog supports the widely used `module/2`, `use_module/1-2`,
+`meta_predicate/1`, and `Module:Goal` interface reflected in later WG17 module
+amendment work. This is a practical module compatibility profile; EyeProlog
+does **not** currently claim a clause-by-clause implementation or certification
+of the complete ISO/IEC 13211-2:2000 module model.
+
+Definite clause grammar support follows the ISO/IEC TS 13211-3 grammar-rule and
+`phrase/2-3` model and is exercised by the conformance corpus. As with Part 1,
+that implementation evidence is not an independent certification of every
+Part 3 requirement. For example:
 
 ```prolog
 sentence --> [hello], noun.
@@ -254,7 +262,7 @@ EyeProlog also adds 128 public library predicate indicators to its 129-entry ISO
 profile. **88 are implemented entirely as ordinary Prolog clauses** in focused
 modules under `src/lib/`; the remaining control predicates and finite-domain
 `library(clpz)` kernel use backtrackable host support.
-They are ISO/IEC 13211-2 modules loaded explicitly by purpose, such as
+They are ordinary Prolog modules using EyeProlog's documented module compatibility surface, loaded explicitly by purpose, such as
 `library(lists)`, `library(lambda)`, `library(strings)`, `library(aggregate)`, or
 `library(clpz)`.
 Portable text

package/examples/book/README.md

@@ -234,7 +234,7 @@ npm run generate
 ## Chapter 38: Language and ISO profile
 
 - [01-city.pl](chapter-38/01-city.pl)
-- [02-look_ahead.pl](chapter-38/02-look_ahead.pl) — ISO Part 3 definite clause grammars
+- [02-look_ahead.pl](chapter-38/02-look_ahead.pl) — Part 3-oriented definite clause grammars
 
 ## Chapter 39: Built-in predicates by programming role
 

package/examples/book/chapter-38/02-look_ahead.pl

@@ -1,2 +1,2 @@
-% From The Art of EyeProlog, Chapter 38 — ISO Part 3 definite clause grammars.
+% From The Art of EyeProlog, Chapter 38 — Part 3-oriented definite clause grammars.
 look_ahead(X), [X] --> [X].

package/package.json

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

package/src/iso.js

@@ -662,6 +662,11 @@ function* currentPrologFlagBuiltin({ solver, goal, env }) {
     throw new PrologError('domain_error(prolog_flag)', flag);
   }
   for (const [name, definition] of solver.prologFlags) {
+    // ISO 7.11.1.1: when bounded=false, max_integer and min_integer have no
+    // current value and current_prolog_flag/2 must therefore not enumerate
+    // them. The definitions remain registered so attempts to change these
+    // non-changeable flags still receive the normal flag error handling.
+    if (definition.value == null) continue;
     const next = env.clone();
     if (unify(goal.args[0], atom(name), next) && unify(goal.args[1], definition.value, next)) yield next;
   }

package/src/parser.js

@@ -207,7 +207,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 +227,26 @@ 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) {
+    return this.source[this.pos + offset] ?? '';
+  }
+  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 +255,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 +297,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 +343,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 +391,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,8 +404,8 @@ 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`);
@@ -373,8 +414,8 @@ class Parser {
     }
     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`);
@@ -411,7 +452,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 +483,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 +539,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 +565,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 +603,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 +620,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 +628,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 +636,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 +987,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 +1133,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 +1438,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 +1473,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/test/conformance/ISO-COMPLIANCE.md

@@ -32,13 +32,13 @@ error-ordering alternative to an individual executable assertion.
 | --- | --- | --- |
 | 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. |
+| 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,24 @@ 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.
+
+The processor-character-set/collation rows in
+[ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md) remain explicit
+`audit gap`s. They were not papered over by narrowing strict mode without full
+WG17 and read/write/error validation.
+
 ## Strict-core boundary
 
 `isoStrict: true` is intentionally a **Part 1 + Corrigenda 1-3** mode. It does
@@ -64,9 +82,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

@@ -35,7 +35,7 @@ Status values are:
 | 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.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`. |
+| 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`. |
@@ -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)
 

package/test/conformance/ISO-MATRIX.md

@@ -19,8 +19,8 @@ compliance audit and the remaining work before a full conformance claim.
 | 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, parenthesized-number rejection, Logtalk-derived error cases |
 | 8.17 flags and hooks | required flags, mutation permissions, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases |
 | Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power` |
-| ISO/IEC 13211-2 modules | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |
-| ISO/IEC TS 13211-3 grammar rules | `-->`, terminal and partial sequences, grammar control constructs, semicontexts, nonterminal indicators, modules, `phrase/2-3`, steadfastness and errors | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_partial_sequences`, `dcg_phrase_steadfastness`, `dcg_dynamic_nonterminal_indicator`, `logtalk_dcg_phrase_identity`, `logtalk_dcg_semicontexts`, DCG error and precedence cases |
+| Module compatibility profile (related to ISO/IEC 13211-2 and later WG17 amendment work) | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |
+| Part 3-oriented DCG compatibility profile | `-->`, terminal and partial sequences, grammar control constructs, semicontexts, nonterminal indicators, modules, `phrase/2-3`, steadfastness and errors | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_partial_sequences`, `dcg_phrase_steadfastness`, `dcg_dynamic_nonterminal_indicator`, `logtalk_dcg_phrase_identity`, `logtalk_dcg_semicontexts`, DCG error and precedence cases |
 
 Corrigendum-specific coverage includes double-quoted atom operator priority
 (Cor.1); the added predicates and evaluable functors, bar-operator rules,
@@ -36,7 +36,9 @@ particular, the index records the unbounded integer model, `double_quotes=chars`
 9.1.4.2 choice to round tiny arithmetic results rather than raise underflow),
 stream/character decisions, and the normal-profile extension boundary.
 
-This is an executable conformance matrix, not a certification issued by an
-independent standards body. Release gating runs the ISO cases and the dedicated
+This is an executable conformance/compatibility matrix, not a certification issued by an
+independent standards body. The Part 2/Part 3-related rows describe tested
+normal-mode compatibility surfaces rather than a claim that every requirement
+of those standards has been closed. Release gating runs the ISO cases and the dedicated
 Part 1 strict-core suite together with the full regression, API, documentation,
 example, and browser suites.

package/test/conformance/README.md

@@ -8,7 +8,7 @@ supported ISO Prolog profile, built-ins, extensions, and reasoner behavior.
 The suite is intentionally file-based. Exact standard output, errors, warnings,
 and proof output test the behavior of the JavaScript implementation.
 [ISO-MATRIX.md](ISO-MATRIX.md) maps Part 1 normative clause families, all three
-corrigenda, Part 2 modules, and Part 3 definite clause grammars to representative
+corrigenda, plus EyeProlog's module and DCG compatibility profiles, to representative
 executable cases. [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
 complete one-to-one trace for the vendored active upstream WG17 syntax cases.
 [STC-DRAFT-STATUS.md](STC-DRAFT-STATUS.md) separately tracks executable
@@ -17,9 +17,8 @@ review evidence, not normative ISO claims.
 
 “Conformance” here means conformance to EyeProlog's documented ISO compatibility
 profile and implementation extensions. The default registry covers the exact
-predicate indicators listed in Appendix B of the book across the supported
-ISO/IEC 13211-1:1995, ISO/IEC 13211-2:2000, and ISO/IEC TS 13211-3:2025
-standard families. [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md) is the explicit
+predicate indicators listed in Appendix B of the book across the Part 1 strict-core
+target and the normal-mode module/DCG compatibility families. [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md) is the explicit
 processor-requirement ledger for the Part 1 strict-core audit. This suite is
 still not an independent certification of every processor requirement, lexical
 edge, option combination, or prescribed error precedence. Cases under `iso/`

package/test/conformance/cases/iso/dcg_module_nonterminal_indicator.pl

@@ -1,4 +1,4 @@
-% Part 2 module exports combined with a Part 3 nonterminal indicator.
+% Module compatibility exports combined with a Part 3 nonterminal indicator.
 :- module(dcg_vocab, [word//1, answer/1]).
 
 word(X) --> [X].

package/test/conformance/expected/iso/exceptions_and_flags.pl

@@ -1,3 +1,3 @@
 answer(7, red, caught(eyeprolog), first, caught(eyeprolog)).
 answer(7, red, caught(eyeprolog), second, caught(eyeprolog)).
-flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_integer, unbounded), pair(min_integer, unbounded), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true)]).
+flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true)]).

package/test/fixtures/README.md

@@ -21,3 +21,10 @@ The corpus snapshot was retrieved on 2026-08-11.
 `prologue_quad_runner.pl` loads EyeProlog's `library(prologue)` and includes
 the unmodified corpus, mirroring the draft's requirement that a Prologue be
 included before its examples are run.
+
+The upstream Prologue snapshot contains one `max_integer` quad that accepts an
+implementation-specific `Max = unbounded` result. EyeProlog deliberately does
+not patch that vendored fixture: with its ISO `bounded=false` choice, Part 1
+7.11.1.1 requires `current_prolog_flag(max_integer, _)` to fail. The regression
+gate therefore records this single standards-driven divergence explicitly while
+requiring the other 32 quads to pass.

package/test/run-iso-strict.mjs

@@ -36,6 +36,26 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(solver.prologFlags.get('unknown')?.value?.name, 'error', 'unknown default');
   });
 
+  reporter.test('unbounded integer profile does not expose max_integer or min_integer values', () => {
+    const program = Program.parse('', { isoStrict: true });
+    const solver = new Solver(program, { isoStrict: true });
+    const answers = (text) => [...solver.solve([parseGoalText(text, { isoStrict: true })], new Env(), 0)].length;
+    equal(answers('current_prolog_flag(bounded,false)'), 1, 'bounded=false');
+    equal(answers('current_prolog_flag(max_integer,_)'), 0, 'max_integer unavailable');
+    equal(answers('current_prolog_flag(min_integer,_)'), 0, 'min_integer unavailable');
+  });
+
+
+  reporter.test('preparation-time char_conversion affects later unquoted source only', () => {
+    const program = Program.parse(
+      ":- char_conversion(x,y).\np(x).\nquoted('x').\n:- set_prolog_flag(char_conversion,off).\nraw(x).\n",
+      { isoStrict: true },
+    );
+    equal(Boolean(program.findGroup('p', 1)?.clauses.some((clause) => clause.head.args[0]?.name === 'y')), true, 'converted p/1');
+    equal(Boolean(program.findGroup('quoted', 1)?.clauses.some((clause) => clause.head.args[0]?.name === 'x')), true, 'quoted atom unchanged');
+    equal(Boolean(program.findGroup('raw', 1)?.clauses.some((clause) => clause.head.args[0]?.name === 'x')), true, 'conversion disabled');
+  });
+
   reporter.test('uses the Part 1 predefined operator table', () => {
     const program = Program.parse('', { isoStrict: true });
     equal(program.operators.has('fx\u0000?-'), true, 'fx ?-');

package/test/run-regression.mjs

@@ -1218,7 +1218,7 @@ c4 ?- call((!;1)).
       },
     },
     {
-      name: 'runQuads passes the complete vendored Prolog Prologue quad corpus',
+      name: 'vendored Prolog Prologue corpus records the bounded=false max_integer divergence',
       run: () => {
         const filename = path.join(testRoot, 'fixtures', 'prologue_quad_runner.pl');
         const source = fs.readFileSync(filename, 'utf8');
@@ -1228,8 +1228,15 @@ c4 ?- call((!;1)).
           baseDir: path.dirname(filename),
         }]));
         assertEqual(result.total, 33, 'quad total');
-        assertEqual(result.passed, 33, 'quad passed');
-        assertEqual(result.stdout, 'quads: 33 run, 33 passed, 0 failed.\n', 'quad report');
+        // The upstream working-draft quad accepts either integer overflow or
+        // Max=unbounded. ISO/IEC 13211-1 7.11.1.1 instead says that when
+        // bounded=false, current_prolog_flag(max_integer, N) fails. Preserve
+        // the upstream fixture unchanged and make that one deliberate
+        // standards-driven divergence explicit in the regression gate.
+        assertEqual(result.passed, 32, 'quad passed');
+        assertEqual(result.failed, 1, 'quad failed');
+        assertIncludes(result.stdout, 'current_prolog_flag(max_integer, Max)', 'max_integer divergence');
+        assertIncludes(result.stdout, 'quads: 33 run, 32 passed, 1 failed.', 'quad report');
       },
     },
     {
@@ -4613,7 +4620,7 @@ answer(ok) :-
       },
     },
     {
-      name: 'ISO Part 2 library modules load Prolog clauses explicitly',
+      name: 'module compatibility libraries load Prolog clauses explicitly',
       run: () => {
         const program = Program.parse(':- use_module(library(lists)).\n:- use_module(library(random)).\nanswer(X) :- append([a], [b], X).');
         const solver = new Solver(program);
@@ -4749,7 +4756,7 @@ repeated(X) :- X in 1..3, all_distinct([X, X]).
       },
     },
     {
-      name: 'Part 2 modules isolate predicates and support selective imports',
+      name: 'module compatibility profile isolates predicates and supports selective imports',
       run: () => {
         const directory = path.join(tmp, `modules-${++tmpCounter}`);
         fs.mkdirSync(directory);
@@ -4774,7 +4781,7 @@ repeated(X) :- X in 1..3, all_distinct([X, X]).
       },
     },
     {
-      name: 'Part 3 nonterminal indicators import through Part 2 modules',
+      name: 'Part 3 nonterminal indicators import through module compatibility profile',
       run: () => {
         const directory = path.join(tmp, `dcg-modules-${++tmpCounter}`);
         fs.mkdirSync(directory);

package/the-art-of-eyeprolog.md

@@ -1943,7 +1943,7 @@ The source layout mirrors the language boundary while keeping the JavaScript
 runtime flat under `src/`. `src/iso.js` remains the stable ISO facade and
 built-in registry; arithmetic evaluation lives in `src/iso-arithmetic.js`, and
 processor control/error classes live in `src/errors.js`. `src/dcg.js`
-implements the shared ISO Part 3 grammar-rule and dynamic-body expansion
+implements the shared Part 3-oriented grammar-rule and dynamic-body expansion
 without depending back on the ISO registry. This keeps the low-level syntax and
 error layers acyclic while preserving the existing `src/iso.js` exports.
 
@@ -1964,8 +1964,8 @@ being split through extra strategy objects or callbacks. Architectural cleanup
 is required to preserve benchmark performance as well as semantics.
 
 Focused files under `src/lib/` contain the portable extensions, with
-`src/lib/lists.pl` supplying common list relations. They are ordinary ISO/IEC
-13211-2 modules, organized like Trealla's `library/` and registered for
+`src/lib/lists.pl` supplying common list relations. They are ordinary Prolog modules using EyeProlog's documented module compatibility
+surface, organized like Trealla's `library/` and registered for
 `library(Name)` by `src/standard-library.js` in Node and the browser. The
 browser entry point `src/playground-worker.js` uses that same program and
 module-loading path in a dedicated worker. `src/ARCHITECTURE.md` records the
@@ -2587,8 +2587,10 @@ correct program without losing its meaning, and organize a decision system
 whose conclusions remain auditable.
 
 EyeProlog supplies the Part 1 control, dynamic-database, operator, and I/O
-facilities together with the Part 2 module forms `module/2`, `use_module/1`,
-`use_module/2`, and `Module:Goal`. Definite-clause grammar notation remains
+facilities together with its normal-profile module forms `module/2`,
+`use_module/1`, `use_module/2`, and `Module:Goal`. These forms are treated as a
+module compatibility surface, not as a claim of complete ISO/IEC 13211-2:2000
+conformance. Definite-clause grammar notation remains
 outside this profile. The examples still prefer explicit domain
 relations, state, and syntax trees where that makes assumptions easier to
 inspect.
@@ -5485,11 +5487,13 @@ The long catalogs are meant to be entered locally, not memorized linearly.
 
 ## 38. Language and ISO profile
 
-The standards baseline is ISO/IEC 13211-1:1995, as corrected by Technical
-Corrigenda 1:2007, 2:2012, and 3:2017, together with the module facilities of
-ISO/IEC 13211-2 and definite clause grammars from ISO/IEC TS 13211-3:2025.
-EyeProlog implements the compatibility profile documented
-here; it does not claim certification as a complete conforming processor.
+The normative strict-core baseline is ISO/IEC 13211-1:1995, as corrected by
+Technical Corrigenda 1:2007, 2:2012, and 3:2017. Normal EyeProlog additionally
+provides a practical module interface aligned with later WG17 module amendment
+work and a definite-clause-grammar profile following ISO/IEC TS 13211-3. Those
+normal-mode profiles are documented and tested compatibility surfaces; they are
+not currently claimed as complete clause-by-clause certifications of Part 2 or
+Part 3.
 
 Prolog source accepted by EyeProlog is UTF-8. `%` starts a line comment and
 `/* ... */` delimits a block comment. Plain atoms begin with a
@@ -5618,10 +5622,11 @@ EyeProlog supports cut, operator declarations, dynamic database updates, grouped
 solutions, exceptions, flags, initialization and inclusion directives, and
 standard stream and term I/O. Normal mode additionally provides lifecycle-aware
 `call_cleanup/2` and `setup_call_cleanup/3`; these cleanup controls are
-EyeProlog extensions and are excluded by `--iso-strict`. ISO Part 2 modules and
-Part 3 definite clause grammars complement this Part 1 core.
+EyeProlog extensions and are excluded by `--iso-strict`. Normal mode also
+adds the documented module compatibility surface and a Part 3-oriented DCG
+profile.
 
-### ISO Part 2 modules
+### Module compatibility profile
 
 A module gives predicate identity one more component: module name, predicate
 name, and arity. The first directive in a module source names the module and
@@ -5657,7 +5662,7 @@ an empty list when only qualified calls are wanted. `Module:Goal` selects a
 module explicitly. Repeated module loads are idempotent, while conflicting
 imports and requests for predicates that a module does not export are errors.
 
-### ISO Part 3 definite clause grammars
+### Part 3-oriented definite clause grammars
 
 A grammar rule `Head --> Body.` is prepared as an ordinary predicate with two
 additional difference-list arguments. Parameterized nonterminals retain their
@@ -5670,7 +5675,7 @@ Nonterminal indicators can be exported and imported through modules:
 word(noun) --> [robot] | [scientist].
 ```
 
-The required grammar constructs are terminal lists, `[]`, sequencing with
+The supported grammar constructs include terminal lists, `[]`, sequencing with
 comma, alternatives with `;` or `|`, if-then-else, embedded goals `{Goal}`,
 `call//1`, `phrase//1`, and `!//0`. Semicontexts provide look-ahead by restoring
 terminals to the remaining sequence:
@@ -5973,7 +5978,7 @@ silently changing a static program.
 | --- | --- |
 | `op(+Priority,+Specifier,+NameOrNames)` | Defines or removes operators in the current program. Priority is `0..1200`; specifiers are `fx`, `fy`, `xf`, `yf`, `xfx`, `xfy`, or `yfx`; names may be one atom or a proper list. Priority zero removes the definition. `,` and `\|` cannot be modified. |
 | `current_op(?Priority,?Specifier,?Name)` | Enumerates active operator definitions and filters supplied arguments. |
-| `char_conversion(+Input,+Output)` | Installs a one-character atom conversion for subsequent term input. Mapping a character to itself removes its custom mapping. |
+| `char_conversion(+Input,+Output)` | Installs a one-character conversion. In prepared Prolog text, later **unquoted** characters are converted when `char_conversion=on`; quoted characters are unchanged. The same mapping initializes execution-time term input. Mapping a character to itself removes its custom mapping. |
 | `current_char_conversion(?Input,?Output)` | Enumerates installed nonidentity conversions. |
 | `current_prolog_flag(?Flag,?Value)` | Enumerates flags or retrieves one named flag. An unknown bound flag raises *domain_error(prolog_flag)*. |
 | `set_prolog_flag(+Flag,+Value)` | Changes a supported mutable flag after validating its allowed atom value. Read-only flags raise a permission error. |
@@ -5984,13 +5989,21 @@ silently changing a static program.
 | `integer_rounding_function` | `toward_zero` | `toward_zero` | no |
 | `char_conversion` | `on` | `on`, `off` | yes |
 | `debug` | `off` | `on`, `off` | yes |
-| `max_integer` | `unbounded` | `unbounded` | no |
-| `min_integer` | `unbounded` | `unbounded` | no |
+| `max_integer` | no current value because `bounded=false` | not applicable | no |
+| `min_integer` | no current value because `bounded=false` | not applicable | no |
 | `max_arity` | `unbounded` | `unbounded` | no |
 | `unknown` | `error` | `error`, `fail`, `warning` | yes |
 | `double_quotes` | `chars` | `chars`, `codes`, `atom` | yes |
 | `occurs_check` | `true` | `true`, `error` | yes |
 
+Because `bounded=false`, `current_prolog_flag(max_integer, _)` and
+`current_prolog_flag(min_integer, _)` fail as required by ISO 7.11.1.1;
+EyeProlog does not expose an `unbounded` sentinel as either flag value.
+Preparation-time `char_conversion/2` mappings affect later unquoted source text
+and also initialize the execution-time conversion mapping; setting the
+`char_conversion` flag to `off` disables conversion for following source text.
+Quoted source characters are not converted.
+
 Both normal EyeProlog and strict ISO core mode use the ISO `unknown=error`
 default. Interactive `set_prolog_flag/2` changes are retained when the REPL
 consults another file or imports a module instead of being reset by the host
@@ -7599,14 +7612,15 @@ npm run test:playground
 
 ### Supported ISO Prolog implementation
 
-EyeProlog executes a documented and tested ISO Prolog implementation based on
-ISO/IEC 13211-1:1995 and its three technical corrigenda, ISO/IEC 13211-2:2000,
-and ISO/IEC TS 13211-3:2025. The exact supported predicate indicators are
+EyeProlog executes a documented and tested ISO-oriented Prolog profile. Its
+strict-core target is ISO/IEC 13211-1:1995 with Technical Corrigenda 1-3. Normal
+mode additionally provides the documented module compatibility surface and a
+Part 3-oriented definite-clause-grammar implementation. The exact supported predicate indicators are
 listed in Chapter 39. The normal profile includes control and exceptions, term
 operations, arithmetic, grouped solutions, dynamic clauses, operators,
 atomic-term processing, flags, character conversion, streams, character/byte
-and term I/O, initialization, source inclusion, Part 2 modules, Part 3 grammar
-rules, and EyeProlog extensions.
+and term I/O, initialization, source inclusion, module compatibility forms,
+definite-clause grammar rules, and EyeProlog extensions.
 
 For a Part 1 conformance boundary, `--iso-strict` (or API option
 `isoStrict: true`) limits the processor to ISO/IEC 13211-1:1995 plus Technical
@@ -7627,7 +7641,7 @@ remaining qualifications are:
 
 - zero-arity compound syntax such as `ready()` is represented by the atom
   `ready`;
-- ISO Part 2 modules and ISO/IEC TS 13211-3 definite clause grammars are supported;
+- module and ISO/IEC TS 13211-3-oriented DCG compatibility profiles are supported in normal mode, without a complete Part 2/Part 3 certification claim;
 - variables cannot occupy functor or predicate position;
 - double-quoted text follows `double_quotes` exactly; the default `chars` value
   matches Trealla and Scryer and may be changed to `codes` or `atom`;

package/why-eyeprolog.md

@@ -6,8 +6,8 @@ answer.
 
 Its design rule is simple:
 
-> **Keep the ISO language core complete, keep extensions small and explicit,
-> and implement portable conveniences as ordinary Prolog whenever possible.**
+> **Keep the ISO language core explicit and auditable, keep extensions small and
+> explicit, and implement portable conveniences as ordinary Prolog whenever possible.**
 
 ## Why ISO Prolog?
 
@@ -17,12 +17,13 @@ arithmetic, control, streams, errors, and processor behavior. Reusing that
 language gives programs recognizable semantics without inventing another rule
 syntax.
 
-EyeProlog implements the Part 1 core together with Technical Corrigenda 1, 2,
-and 3, Part 2 modules, and the Part 3 definite clause grammar specification.
-Its executable conformance matrix and tests document the supported
-behavior, including an executable trace of the vendored active WG17 syntax
-cases. This is extensive implementation evidence, not certification by an
-independent standards body.
+EyeProlog targets the Part 1 core together with Technical Corrigenda 1, 2,
+and 3, and provides documented module and definite-clause-grammar compatibility
+profiles for normal-mode programs. Its executable conformance matrix and tests
+document the supported behavior, including an executable trace of the vendored
+active WG17 syntax cases. This is extensive implementation evidence, not a
+claim that every Part 1, Part 2, or Part 3 normative requirement has already
+been certified or closed.
 
 ## Why a small implementation?
 
@@ -34,8 +35,8 @@ keeps a narrow architecture:
 - explicit `tnot/1` with well-founded semantics for finite, range-restricted,
   function-free Datalog components;
 - the ISO built-in registry;
-- lean portable ISO Part 2 library modules;
-- ISO Part 3 definite clause grammars and `phrase/2-3`;
+- lean portable library modules using the documented module compatibility profile;
+- ISO Part 3-oriented definite clause grammars and `phrase/2-3`;
 - lifecycle-aware `call_cleanup/2` and `setup_call_cleanup/3` in normal mode;
 - optional proof explanations; and
 - the same implementation in Node.js and the browser.
@@ -72,8 +73,8 @@ positive Datalog closures with a shared relation-wide table, but the admission
 heuristics are implementation details. Programs should rely on the documented
 semantics and finiteness conditions, not on a particular internal threshold.
 
-DCGs follow the same rule.  Their meaning remains the ISO Part 3 difference-list
-model, while finite sequence scans and proven zero-width hand-offs may use
+DCGs follow the same rule. Their supported semantics follow the ISO Part 3
+difference-list model, while finite sequence scans and proven zero-width hand-offs may use
 lighter internal control paths so deep grammars do not pay one general solver
 frame per token.  Relational remainder-producing modes are preserved.  The
 checked `examples/dcg-expression-language.pl` program shows the declarative side
@@ -122,7 +123,7 @@ and integrations that can live outside the reasoning engine.
 ## The durable idea
 
 EyeProlog demonstrates that a useful proof-producing reasoner can be built from
-a complete standard core, small portable modules, and an ordinary JavaScript
+a carefully audited standard-oriented core, small portable modules, and an ordinary JavaScript
 API. Its value is not feature count; it is that the language boundary stays
 visible enough to understand.