eyeprolog 1.3.42 → 1.3.43

package/README.md

@@ -210,6 +210,14 @@ expansion/`phrase/2-3`; it also removes the EyeProlog `occurs_check` flag,
 Normal mode is unchanged and continues to support modules, DCGs, quads,
 libraries, proofs, cleanup-aware control, and the other documented extensions.
 
+Strict mode also makes the Part 1 processor-character-set choice explicit: its
+PCS is 7-bit ASCII (U+0000..U+007F), C0 controls and DEL are classified as
+extended layout characters, and the collating-sequence integer of each
+character is its ASCII code. Characters or character codes outside that set
+raise representation errors in strict parsing and character operations. Normal
+mode retains Unicode scalar character data as an implementation-specific
+extension.
+
 The auditable processor-requirement checklist lives in
 [`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md).
 The ISO 5.4 implementation-defined/implementation-specific decision index is

package/package.json

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

package/src/iso-character.js

@@ -0,0 +1,37 @@
+// ISO/IEC 13211-1 processor-character-set choices used by --iso-strict.
+//
+// EyeProlog's strict Part 1 profile deliberately chooses a finite PCS so every
+// accepted character has one documented lexical classification and one stable
+// collating-sequence integer. Normal mode keeps the broader Unicode surface as
+// an implementation-specific extension.
+
+export class CharacterRepresentationError extends Error {
+  constructor(formal = 'representation_error(character)') {
+    super(`error(${formal})`);
+    this.name = 'CharacterRepresentationError';
+    this.formal = formal;
+  }
+}
+
+// Strict PCS: the 128 ASCII characters U+0000..U+007F. Printable ASCII
+// carries the Part 1 lexical classes; the remaining C0 controls plus DEL are
+// implementation-defined extended layout characters. This lets every ISO
+// octal/hexadecimal character escape in the ASCII range denote a PCS member.
+// The collating-sequence integer is the Unicode/ASCII code point.
+export function isStrictIsoPcsCodePoint(code) {
+  return Number.isInteger(code) && code >= 0 && code <= 0x7f;
+}
+
+export function isStrictIsoPcsCharacter(character) {
+  if (typeof character !== 'string' || Array.from(character).length !== 1) return false;
+  return isStrictIsoPcsCodePoint(character.codePointAt(0));
+}
+
+export function strictIsoCollatingInteger(character) {
+  return isStrictIsoPcsCharacter(character) ? character.codePointAt(0) : null;
+}
+
+export function assertStrictIsoPcsCharacter(character, formal = 'representation_error(character)') {
+  if (!isStrictIsoPcsCharacter(character)) throw new CharacterRepresentationError(formal);
+  return character;
+}

package/src/iso.js

@@ -13,6 +13,7 @@ import {
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 import { INVALID_UTF8_SENTINEL } from './io.js';
+import { CharacterRepresentationError, isStrictIsoPcsCharacter, isStrictIsoPcsCodePoint } from './iso-character.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -777,7 +778,7 @@ function* currentOpBuiltin({ solver, goal, env }) {
   }
 }
 
-function conversionCharacter(term, env, current = false) {
+function conversionCharacter(term, env, current = false, solver = null) {
   const value = deref(term, env);
   if (value.type === VAR) {
     if (current) return value;
@@ -787,18 +788,21 @@ function conversionCharacter(term, env, current = false) {
     if (current) throw new PrologError('type_error(character)', value);
     throw new PrologError('representation_error(character)');
   }
+  if (solver?.isoStrict && !isStrictIsoPcsCharacter(value.name)) {
+    throw new PrologError('representation_error(character)', value);
+  }
   return value;
 }
 function* charConversionBuiltin({ solver, goal, env }) {
-  const input = conversionCharacter(goal.args[0], env);
-  const output = conversionCharacter(goal.args[1], env);
+  const input = conversionCharacter(goal.args[0], env, false, solver);
+  const output = conversionCharacter(goal.args[1], env, false, solver);
   if (input.name === output.name) solver.charConversions.delete(input.name);
   else solver.charConversions.set(input.name, output.name);
   yield env;
 }
 function* currentCharConversionBuiltin({ solver, goal, env }) {
-  const input = conversionCharacter(goal.args[0], env, true);
-  const output = conversionCharacter(goal.args[1], env, true);
+  const input = conversionCharacter(goal.args[0], env, true, solver);
+  const output = conversionCharacter(goal.args[1], env, true, solver);
   for (const [from, to] of [...solver.charConversions]) {
     const next = env.clone();
     if (unify(input, atom(from), next) && unify(output, atom(to), next)) yield next;
@@ -1044,6 +1048,9 @@ function inputUnitBuiltin(name) {
       throw error;
     }
     if (unit == null && !peek) stream.pastEnd = true;
+    if (!binary && unit != null && solver.isoStrict && !isStrictIsoPcsCharacter(unit)) {
+      throw new PrologError('representation_error(character)');
+    }
     const result = unit == null ? (binary ? numberTerm(-1) : name.endsWith('code') ? numberTerm(-1) : atom('end_of_file'))
       : binary ? numberTerm(unit) : name.endsWith('code') ? numberTerm(unit.codePointAt(0)) : atom(unit);
     const target = goal.args[goal.arity - 1];
@@ -1059,6 +1066,9 @@ function outputUnitBuiltin(name) {
     if (name === 'put_char') {
       if (stream.type !== 'text') throw new PrologError('permission_error(output, binary_stream)', streamHandle(stream.id));
       if (!oneChar(value)) throw new PrologError('type_error(character)', value);
+      if (solver.isoStrict && !isStrictIsoPcsCharacter(value.name)) {
+        throw new PrologError('representation_error(character)', value);
+      }
       solver.io.writeUnit(stream, value.name);
     } else {
       if ((name === 'put_byte') !== (stream.type === 'binary')) {
@@ -1068,6 +1078,9 @@ function outputUnitBuiltin(name) {
       const code = BigInt(value.name);
       const max = name === 'put_byte' ? 255n : 0x10ffffn;
       if (code < 0n || code > max) throw new PrologError(name === 'put_byte' ? 'type_error(byte)' : 'representation_error(character_code)');
+      if (name === 'put_code' && solver.isoStrict && !isStrictIsoPcsCodePoint(Number(code))) {
+        throw new PrologError('representation_error(character_code)');
+      }
       solver.io.writeUnit(stream, name === 'put_byte' ? Number(code) : String.fromCodePoint(Number(code)));
     }
     yield env;
@@ -1095,6 +1108,9 @@ function* termTextCandidates(stream, solver) {
   let quote = null, lineComment = false, blockComment = false;
   for (let i = stream.position; i < source.length; i++) {
     const ch = source[i], next = source[i + 1];
+    if (solver.isoStrict && !isStrictIsoPcsCodePoint(ch.charCodeAt(0))) {
+      throw new PrologError('representation_error(character)');
+    }
     // Text streams preserve invalid UTF-8 bytes as an impossible Unicode
     // sentinel.  read/1-2 and read_term/2-3 must surface the same character
     // representation error as get_char/1-2 instead of misclassifying the
@@ -1106,7 +1122,7 @@ function* termTextCandidates(stream, solver) {
     if (blockComment) { if (ch === '*' && next === '/') { blockComment = false; i++; } continue; }
     if (quote) {
       if (ch === '\\') i = quotedEscapeEnd(source, i);
-      else if (ch !== ' ' && /^[\u0009-\u000d]$/.test(ch)) {
+      else if (ch !== ' ' && /^[\u0000-\u001f\u007f]$/.test(ch)) {
         // Literal layout characters are not quoted characters (6.4.2.1).
         // Surface the lexical error immediately even when there is no later
         // full stop; otherwise read/1 would misreport malformed input as EOF.
@@ -1137,7 +1153,7 @@ function hasNonLayoutRemainder(source, start) {
   return lastNonLayoutIndex(source, start) >= start;
 }
 function lastNonLayoutIndex(source, start = 0) {
-  const ignored = /[\u0009-\u000d\u0020]+|%[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\//g;
+  const ignored = /[\u0000-\u0020\u007f]+|%[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\//g;
   ignored.lastIndex = start;
   let cursor = start;
   let last = -1;
@@ -1248,7 +1264,9 @@ function readTermFromStream(stream, solver) {
         stream.position = candidate.end;
         return scopeReadTerm(term);
       } catch (error) {
-        if (error instanceof NumberRepresentationError) throw new PrologError(error.formal);
+        if (error instanceof NumberRepresentationError || error instanceof CharacterRepresentationError) {
+          throw new PrologError(error.formal);
+        }
         // A dot inside a graphic operator, such as =.., is only a possible
         // terminator. Keep scanning until a complete term parses.
       }
@@ -1510,30 +1528,35 @@ function oneChar(value) {
   return value.type === ATOM && characters(value.name).length === 1;
 }
 
-function validCharacterCode(value) {
+function validCharacterCode(value, solver = null) {
   if (value.type !== NUMBER || !isDecimalInteger(value.name)) return false;
   const code = BigInt(value.name);
-  return code >= 0n && code <= 0x10ffffn && !(code >= 0xd800n && code <= 0xdfffn);
+  if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) return false;
+  return !solver?.isoStrict || isStrictIsoPcsCodePoint(Number(code));
 }
 
-function listToAtomInput(list, env, kind) {
+function listToAtomInput(list, env, kind, solver = null) {
   const { items, tail } = listElements(list, env);
   if (tail.type === VAR || items.some((item) => item.type === VAR)) throw new PrologError('instantiation_error');
   if (tail.type !== ATOM || tail.name !== '[]') throw new PrologError('type_error(list)', tail);
   if (kind === 'chars') {
     const invalid = items.find((item) => !oneChar(item));
     if (invalid) throw new PrologError('type_error(character)', invalid);
+    if (solver?.isoStrict) {
+      const outsidePcs = items.find((item) => !isStrictIsoPcsCharacter(item.name));
+      if (outsidePcs) throw new PrologError('representation_error(character)', outsidePcs);
+    }
     return items.map((item) => item.name).join('');
   }
   const nonInteger = items.find((item) => item.type !== NUMBER || !isDecimalInteger(item.name));
   if (nonInteger) throw new PrologError('type_error(integer)', nonInteger);
-  const invalid = items.find((item) => !validCharacterCode(item));
+  const invalid = items.find((item) => !validCharacterCode(item, solver));
   if (invalid) throw new PrologError('representation_error(character_code)');
   return items.map((item) => String.fromCodePoint(Number(item.name))).join('');
 }
 
 function atomListBuiltin(kind) {
-  return function* ({ goal, env }) {
+  return function* ({ solver, goal, env }) {
     const value = deref(goal.args[0], env);
     if (value.type !== VAR && value.type !== ATOM) throw new PrologError('type_error(atom)', value);
     const list = deref(goal.args[1], env);
@@ -1546,7 +1569,7 @@ function atomListBuiltin(kind) {
       }
       const invalid = supplied.find((item) => item.type !== VAR &&
         (kind === 'chars' ? !oneChar(item) :
-          item.type !== NUMBER || !isDecimalInteger(item.name) || !validCharacterCode(item)));
+          item.type !== NUMBER || !isDecimalInteger(item.name) || !validCharacterCode(item, solver)));
       if (invalid) {
         if (kind === 'chars') throw new PrologError('type_error(character)', invalid);
         if (invalid.type !== NUMBER || !isDecimalInteger(invalid.name)) {
@@ -1554,26 +1577,32 @@ function atomListBuiltin(kind) {
         }
         throw new PrologError('representation_error(character_code)');
       }
+      if (solver.isoStrict && characters(value.name).some((ch) => !isStrictIsoPcsCharacter(ch))) {
+        throw new PrologError('representation_error(character)', value);
+      }
       const items = characters(value.name).map((ch) =>
         kind === 'chars' ? atom(ch) : numberTerm(ch.codePointAt(0)));
       if (unify(goal.args[1], listFromItems(items), next)) yield next;
       return;
     }
-    if (unify(goal.args[0], atom(listToAtomInput(list, env, kind)), next)) yield next;
+    if (unify(goal.args[0], atom(listToAtomInput(list, env, kind, solver)), next)) yield next;
   };
 }
 const atomCharsBuiltin = atomListBuiltin('chars');
 const atomCodesBuiltin = atomListBuiltin('codes');
 
-function* charCodeBuiltin({ goal, env }) {
+function* charCodeBuiltin({ solver, goal, env }) {
   const char = deref(goal.args[0], env);
   const code = deref(goal.args[1], env);
   if (char.type === VAR && code.type === VAR) throw new PrologError('instantiation_error');
   if (char.type !== VAR && !oneChar(char)) throw new PrologError('type_error(character)', char);
+  if (char.type === ATOM && solver.isoStrict && !isStrictIsoPcsCharacter(char.name)) {
+    throw new PrologError('representation_error(character)', char);
+  }
   if (code.type !== VAR && (code.type !== NUMBER || !isDecimalInteger(code.name))) {
     throw new PrologError('type_error(integer)', code);
   }
-  if (code.type !== VAR && !validCharacterCode(code)) throw new PrologError('representation_error(character_code)');
+  if (code.type !== VAR && !validCharacterCode(code, solver)) throw new PrologError('representation_error(character_code)');
   const next = env.clone();
   if (char.type === ATOM) {
     if (unify(goal.args[1], numberTerm(char.name.codePointAt(0)), next)) yield next;
@@ -1583,7 +1612,7 @@ function* charCodeBuiltin({ goal, env }) {
 function skipNumberLayout(text, start) {
   let position = start;
   while (true) {
-    while (position < text.length && /[\u0009-\u000d\u0020]/.test(text[position])) {
+    while (position < text.length && /[\u0000-\u0020\u007f]/.test(text[position])) {
       position++;
     }
     if (text[position] === '%') {
@@ -1647,7 +1676,7 @@ function parseIsoNumber(text) {
     // there without separating layout: `/` *can* continue the graphic token,
     // and the eager-consumer rule therefore keeps `-/**/1` ill-formed (the
     // number_chars continuation corpus case 24).
-    if (/[\u0009-\u000d\u0020]/.test(next) || next === '%') {
+    if (/[\u0000-\u0020\u007f]/.test(next) || next === '%') {
       position = skipNumberLayout(text, position + 1);
       sign = '-';
     }

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) {
@@ -232,7 +236,11 @@ class Parser {
     return this.parserFlagState.charConversions.get(character) ?? character;
   }
   rawPeek(offset = 0) {
-    return this.source[this.pos + offset] ?? '';
+    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();
@@ -410,6 +418,7 @@ class Parser {
       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)) {
@@ -420,6 +429,7 @@ class Parser {
       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

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,8 +30,8 @@ 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. |
+| 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. |
@@ -59,10 +59,15 @@ conformance claims:
   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.
+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
 

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

@@ -19,21 +19,21 @@ 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 | 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()`. |
@@ -68,7 +68,7 @@ Status values are:
 | 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. |
+| 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`. |
@@ -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. |

package/test/conformance/ISO-MATRIX.md

@@ -8,7 +8,7 @@ compliance audit and the remaining work before a full conformance claim.
 
 | Standard area | Implementation | Representative executable coverage |
 | --- | --- | --- |
-| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, syntax error cases |
+| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments, strict ASCII PCS/collation | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, strict PCS/collation tests in `run-iso-strict.mjs`, syntax error cases |
 | Clause 7 term order and unification | finite-tree unification, identity, standard order, errors | `unification_control_information`, `swipl_occurs_check`, `term_modes_and_ordering`, `logtalk_compare_standard_order` |
 | Clause 7 control and exceptions | call, cut, conjunction, disjunction, if-then-else, catch and throw | `cut_control`, `control_and_terms`, `exceptions_and_flags`, `corrigenda_catch_callability`, `throw_copies_ball` |
 | 8.2-8.5 term predicates | unification, Corrigendum 2 tests, comparison, sorting, creation and decomposition | `corrigenda_term_predicates`, `corrigenda_sort_keysort`, `logtalk_arg_unification`, `logtalk_univ`, associated error cases |

package/test/conformance/README.md

@@ -26,7 +26,10 @@ identify standards-derived behavior; other directories cover EyeProlog host
 contracts and extensions. EyeProlog-only execution features such as automatic
 tabling and `tnot/1` well-founded negation are outside the Part 1 strict-core
 claim. Their focused semantic coverage lives primarily in regression tests;
-`tnot/1` is absent from the strict ISO registry.
+`tnot/1` is absent from the strict ISO registry. The strict processor character
+set is the documented 7-bit ASCII PCS with ASCII-code collation; normal-mode
+Unicode character data is tested as an extension rather than folded into the
+Part 1 claim.
 
 All conformance files live under topic directories such as `arithmetic/`, `lists/`, `syntax/`, or `variables/`; new top-level numbered files should not be added. The report uses those directories as coverage categories.
 

package/test/run-iso-strict.mjs

@@ -56,6 +56,57 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(Boolean(program.findGroup('raw', 1)?.clauses.some((clause) => clause.head.args[0]?.name === 'x')), true, 'conversion disabled');
   });
 
+
+  reporter.test('uses a documented 7-bit ASCII processor character set and collation', () => {
+    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("char_code('\\0\\',0)"), 1, 'NUL collating integer');
+    equal(answers("char_code('A',65)"), 1, 'A collating integer');
+    equal(answers("char_code('\\177\\',127)"), 1, 'DEL collating integer');
+    equal(answers("'\\0\\' @< 'A'"), 1, 'control before capital');
+    equal(answers("'A' @< 'a'"), 1, 'capital before small letter');
+  });
+
+
+  reporter.test('follows the Part 1 standard term-type and atom ordering', () => {
+    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("X @< 1.0"), 1, 'variable before float');
+    equal(answers("1.0 @< 1"), 1, 'float before integer');
+    equal(answers("1 @< a"), 1, 'integer before atom');
+    equal(answers("a @< f(a)"), 1, 'atom before compound');
+    equal(answers("'' @< 'A'"), 1, 'null atom first');
+    equal(answers("'A' @< 'B'"), 1, 'atom collation');
+  });
+
+  reporter.test('rejects characters outside the strict processor character set', () => {
+    const sourceError = capture(() => Program.parse("p('é').\n", { isoStrict: true }));
+    equal(sourceError.formal, 'representation_error(character)', 'source representation error');
+
+    const readError = capture(() => run('', {
+      isoStrict: true,
+      goal: 'read(X)',
+      ioOptions: { input: "'é'." },
+    }));
+    equal(readError.formal, 'representation_error(character)', 'read representation error');
+  });
+
+  reporter.test('restricts strict character codes to the processor character set', () => {
+    const charCodeError = capture(() => run('', { isoStrict: true, goal: 'char_code(_,128)' }));
+    equal(charCodeError.formal, 'representation_error(character_code)', 'char_code/2');
+    const atomCodesError = capture(() => run('', { isoStrict: true, goal: 'atom_codes(_, [128])' }));
+    equal(atomCodesError.formal, 'representation_error(character_code)', 'atom_codes/2');
+    const putCodeError = capture(() => run('', { isoStrict: true, goal: 'put_code(128)' }));
+    equal(putCodeError.formal, 'representation_error(character_code)', 'put_code/1');
+  });
+
+  reporter.test('keeps broader Unicode character handling as a normal-mode extension', () => {
+    const result = run('', { goal: "char_code('é',233)" });
+    equal(result.stdout, "char_code('é', 233).\n", 'normal Unicode char_code/2');
+  });
+
   reporter.test('uses the Part 1 predefined operator table', () => {
     const program = Program.parse('', { isoStrict: true });
     equal(program.operators.has('fx\u0000?-'), true, 'fx ?-');

package/the-art-of-eyeprolog.md

@@ -5119,8 +5119,13 @@ this part makes control, reflection, state, operators, and streams explicit.
 For Part 1 portability work, EyeProlog also provides a strict core mode:
 `--iso-strict` on the CLI or `isoStrict: true` in the JavaScript API restricts
 the language/runtime surface to ISO/IEC 13211-1:1995 plus Technical Corrigenda
-1–3. Isolated mode and error cases live in `test/conformance/cases/iso/`. The
-examples here compose those operations into programs worth changing and
+1–3. Its processor character set is the 128-character ASCII set U+0000..U+007F;
+C0 controls and DEL are implementation-defined extended layout characters, and
+collating-sequence integers are the corresponding ASCII codes. Character data
+outside that PCS is rejected with a representation error in strict mode. Normal
+mode keeps EyeProlog's broader Unicode scalar character support as an explicit
+extension. Isolated mode and error cases live in `test/conformance/cases/iso/`.
+The examples here compose those operations into programs worth changing and
 rerunning.
 
 These facilities do not all have the same declarative character. Term
@@ -5495,15 +5500,20 @@ 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
+Normal-mode Prolog source accepted by EyeProlog is UTF-8. `%` starts a line
+comment and `/* ... */` delimits a block comment. Plain atoms begin with a
 lowercase ASCII letter. Variables begin with uppercase or underscore. The bare
 `_` is fresh each time. Single quotes delimit quoted atoms; double quotes use
-ISO double-quoted-list notation. Integers, decimals, scientific notation, binary/octal/
-hexadecimal integers, and character-code constants are accepted.
+ISO double-quoted-list notation. Integers, decimals, scientific notation,
+binary/octal/hexadecimal integers, and character-code constants are accepted.
 
-Unquoted names deliberately use ASCII spelling. Unicode belongs inside quoted
-atoms and double-quoted lists:
+For `--iso-strict`, the processor character set is deliberately narrower and
+fully documented: U+0000..U+007F. Printable ASCII uses the Part 1 lexical
+classes; C0 controls and DEL are extended layout characters; character-code and
+collation values are the same ASCII integers 0..127. Non-ASCII input is a
+representation error. In normal mode, unquoted names still deliberately use
+ASCII spelling while Unicode scalar values may appear inside quoted atoms and
+double-quoted lists:
 
 ```eyeprolog
 
@@ -6036,8 +6046,8 @@ quoted_atom("ab").           % quoted_atom(ab)
 | `atom_length(+Atom,?Length)` | Counts Unicode code points, not UTF-16 code units. A supplied length must be a nonnegative integer. |
 | `atom_concat(?Prefix,?Suffix,?Whole)` | Concatenates two atoms, removes a supplied prefix or suffix, or enumerates every split when only `Whole` is bound. At least `Whole`, or both parts, must determine the operation. |
 | `sub_atom(+Atom,?Before,?Length,?After,?SubAtom)` | Enumerates substrings and their Unicode-code-point offsets. Supplied counts must be nonnegative integers. |
-| `atom_chars(?Atom,?Chars)`, `atom_codes(?Atom,?Codes)` | Convert between an atom and a proper list of one-character atoms or Unicode scalar codes. At least one side must be instantiated. |
-| `char_code(?Character,?Code)` | Converts one character atom and one Unicode scalar code. Surrogates and values outside `0..0x10ffff` raise a representation error. |
+| `atom_chars(?Atom,?Chars)`, `atom_codes(?Atom,?Codes)` | Convert between an atom and a proper list of one-character atoms or character codes. Strict mode uses its ASCII PCS/codes `0..127`; normal mode extends codes to Unicode scalar values. At least one side must be instantiated. |
+| `char_code(?Character,?Code)` | Converts one character atom and its collating/code value. Strict mode accepts only the ASCII PCS `0..127`; normal mode accepts Unicode scalar codes and rejects surrogates/out-of-range values. |
 | `number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)` | Convert finite numbers to canonical text or parse a proper character/code list using ISO number and negative-number syntax, including radix integers, character-code constants, and leading layout. The input is not parsed as a general term: grouping such as `(0)` is a syntax error. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*. |
 
 Conversions accept partial output lists when the atomic input is known, but
@@ -6078,12 +6088,12 @@ input or output.
 | `at_end_of_stream`, `at_end_of_stream(+Stream)` | Succeeds when the current or selected input position is at or beyond its content. |
 | `get_char(?Character)`, `get_char(+Stream,?Character)` | Reads one text character; end of input is `end_of_file`. |
 | `peek_char(?Character)`, `peek_char(+Stream,?Character)` | Observes the next text character without advancing. |
-| `get_code(?Code)`, `get_code(+Stream,?Code)` | Reads a Unicode code point; end of input is `-1`. |
-| `peek_code(?Code)`, `peek_code(+Stream,?Code)` | Observes the next Unicode code point without advancing. |
+| `get_code(?Code)`, `get_code(+Stream,?Code)` | Reads a character code; end of input is `-1`. Strict mode requires the ASCII PCS, while normal mode returns Unicode scalar codes. |
+| `peek_code(?Code)`, `peek_code(+Stream,?Code)` | Observes the next character code without advancing; strict mode requires the ASCII PCS. |
 | `get_byte(?Byte)`, `get_byte(+Stream,?Byte)` | Reads one unit from a binary stream; end of input is `-1`. |
 | `peek_byte(?Byte)`, `peek_byte(+Stream,?Byte)` | Observes the next binary unit without advancing. |
 | `put_char(+Character)`, `put_char(+Stream,+Character)` | Writes one character atom to a text stream. |
-| `put_code(+Code)`, `put_code(+Stream,+Code)` | Writes one Unicode scalar code to a text stream. |
+| `put_code(+Code)`, `put_code(+Stream,+Code)` | Writes one character code to a text stream. Strict mode accepts `0..127`; normal mode accepts Unicode scalar codes. |
 | `put_byte(+Byte)`, `put_byte(+Stream,+Byte)` | Writes an integer in `0..255` to a binary stream. |
 | `nl`, `nl(+Stream)` | Writes a newline to a text stream. |
 

package/why-eyeprolog.md

@@ -19,7 +19,10 @@ syntax.
 
 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
+profiles for normal-mode programs. Strict mode makes its processor character
+model explicit: 7-bit ASCII is the PCS, ASCII code points are the collating
+integers, and normal-mode Unicode character data is an extension rather than an
+implicit part of the Part 1 claim. 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